femto-editor 0.0.1__tar.gz

femto_editor-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Femto Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

femto_editor-0.0.1/PKG-INFO

@@ -0,0 +1,107 @@
+Metadata-Version: 2.4
+Name: femto-editor
+Version: 0.0.1
+Summary: Femto - a tiny nano-style terminal text editor in pure Python
+Author: Femto Contributors
+License: MIT License
+        
+        Copyright (c) 2024 Femto Contributors
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/codewithzaqar/femto
+Keywords: editor,terminal,curses,nano,text-editor,tui
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console :: Curses
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Text Editors :: Text Processing
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: windows-curses; sys_platform == "win32"
+Dynamic: license-file
+
+# Femto v0.0.1
+     
+Femto is a tiny, nano-style terminal text editor written in **pure Python**.
+It ships with zero runtime dependencies on POSIX system (standard-library `curses` only) and automatically pulls `windows-curses` on Windows.
+
+## Install
+
+```bash
+# From source
+pip install .
+
+# Or directly from the repository
+pip install git+https://github.com/codewithzaqar/femto
+
+# Developers: run without installing
+python -m femto myfile.txt
+```
+
+After installation the `femto` command is available globally.
+
+## Usage
+```bash
+femto [file]        # open or create a file
+femto --tab=size 2 x.py # override tab width
+femto --no-wrap long.log # horizontal scrolling instead of soft wrap
+femto --version
+```
+
+## Keybindings
+
+|Key|Action|Key|Action|
+|---|---|---|---|
+|`Ctrl+X`|Exit (asks to save)|`Ctrl+W`|Search / find next|
+|`Ctrl+S`|Save (Save-As if unnamed)|`Ctrl+T`|Go to line|
+|`Ctrl+Z`/`Ctrl+Y`|Undo / Redo|`Ctrl+G`/`Esc`|Cancel prompt|
+|`Arrows`|Move|`Ctrl+<-/->`|Word jump|
+|`Home/End`, `Ctrl+A/E`|Line start/end|`PgUp/PgDn`|Page scroll|
+|`Tab`/`Shift+Tab`|Indent / unindent|`Enter`|New line|
+
+## Configuration (`~/.femtorc` or `./.femtorc`)
+
+```ini
+# comment
+tab_size = 4
+smooth_scroll_margin = 3
+soft_wrap = true
+```
+
+## Running the tests
+
+```bash
+python -m unittest discover -s tests -v
+```
+
+## Building a release
+
+```bash
+pip install build twine
+python -m build          # creates dist/femto_editor-0.0.1-*.whl
+python -m twine upload dist/* # publish to PyPI
+```
+
+## License
+
+MIT - see [LICENSE](LICENSE).

femto_editor-0.0.1/README.md

@@ -0,0 +1,65 @@
+# Femto v0.0.1
+     
+Femto is a tiny, nano-style terminal text editor written in **pure Python**.
+It ships with zero runtime dependencies on POSIX system (standard-library `curses` only) and automatically pulls `windows-curses` on Windows.
+
+## Install
+
+```bash
+# From source
+pip install .
+
+# Or directly from the repository
+pip install git+https://github.com/codewithzaqar/femto
+
+# Developers: run without installing
+python -m femto myfile.txt
+```
+
+After installation the `femto` command is available globally.
+
+## Usage
+```bash
+femto [file]        # open or create a file
+femto --tab=size 2 x.py # override tab width
+femto --no-wrap long.log # horizontal scrolling instead of soft wrap
+femto --version
+```
+
+## Keybindings
+
+|Key|Action|Key|Action|
+|---|---|---|---|
+|`Ctrl+X`|Exit (asks to save)|`Ctrl+W`|Search / find next|
+|`Ctrl+S`|Save (Save-As if unnamed)|`Ctrl+T`|Go to line|
+|`Ctrl+Z`/`Ctrl+Y`|Undo / Redo|`Ctrl+G`/`Esc`|Cancel prompt|
+|`Arrows`|Move|`Ctrl+<-/->`|Word jump|
+|`Home/End`, `Ctrl+A/E`|Line start/end|`PgUp/PgDn`|Page scroll|
+|`Tab`/`Shift+Tab`|Indent / unindent|`Enter`|New line|
+
+## Configuration (`~/.femtorc` or `./.femtorc`)
+
+```ini
+# comment
+tab_size = 4
+smooth_scroll_margin = 3
+soft_wrap = true
+```
+
+## Running the tests
+
+```bash
+python -m unittest discover -s tests -v
+```
+
+## Building a release
+
+```bash
+pip install build twine
+python -m build          # creates dist/femto_editor-0.0.1-*.whl
+python -m twine upload dist/* # publish to PyPI
+```
+
+## License
+
+MIT - see [LICENSE](LICENSE).

femto_editor-0.0.1/femto/__init__.py

@@ -0,0 +1,7 @@
+"""
+Femto - A tiny nano-style terminal text editor.
+"""
+
+__version__ = "0.0.1"
+__author__ = "Femto Contributors"
+__app_name__ = "Femto"

femto_editor-0.0.1/femto/__main__.py

@@ -0,0 +1,60 @@
+"""
+Command-line entry point for Femto.
+
+Enables:
+    python -m femto [file]
+    femto [file]            (console script installed by pip)
+"""
+
+import argparse
+import sys
+
+from femto import __version__, __app_name__
+from femto.app import Application
+
+
+def build_parser():
+    parser = argparse.ArgumentParser(
+        prog="femto",
+        description="Femto - a tiny nano-style terminal text editor.",
+    )
+    parser.add_argument(
+        "filename", nargs="?", default=None,
+        help="file to open (created on save if it does not exist)",
+    )
+    parser.add_argument(
+        "--version", action="version",
+        version=f"{__app_name__} {__version__}",
+    )
+    parser.add_argument(
+        "--tab-size", type=int, default=None, metavar="N",
+        help="spaces inserted by Tab (overrides .femtorc)",
+    )
+    parser.add_argument(
+        "--scroll-margin", type=int, default=None, metavar="N",
+        help="smooth-scroll margin in rows (overrides .femtorc)",
+    )
+    parser.add_argument(
+        "--no-wrap", action="store_true",
+        help="disable soft line wrapping (use horizontal scrolling)",
+    )
+    return parser
+
+
+def main(argv=None):
+    args = build_parser().parse_args(argv)
+
+    app = Application(args.filename)
+    if args.tab_size is not None and args.tab_size >= 1:
+        app.config.tab_size = args.tab_size
+    if args.scroll_margin is not None and args.scroll_margin >= 0:
+        app.config.smooth_scroll_margin = args.scroll_margin
+    if args.no_wrap:
+        app.config.soft_wrap = False
+
+    app.run()
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

femto_editor-0.0.1/femto/app.py

@@ -0,0 +1,330 @@
+"""
+Main Application Controller for Femto.
+"""
+
+import signal
+import curses
+
+from femto.buffer import Buffer
+from femto.cursor import Cursor
+from femto.renderer import Renderer
+from femto.layout import get_visual_position, get_logical_from_visual
+from femto.prompt import Prompt
+from femto.history import History
+from femto.config import Config
+from femto.keys import Key, is_backspace, is_enter
+
+
+def _ignore_suspend():
+    """Ignore SIGTSTP where it exists (POSIX); no-op on Windows."""
+    sig = getattr(signal, "SIGTSTP", None)
+    if sig is None:
+        return
+    try:
+        signal.signal(sig, signal.SIG_IGN)
+    except (OSError, ValueError):
+        pass
+
+
+class Mode:
+    NORMAL = "normal"
+    SAVE_AS = "save_as"
+    SEARCH = "search"
+    GOTO_LINE = "goto_line"
+    EXIT_CONFIRM = "exit_confirm"
+
+
+class Application:
+    def __init__(self, filename=None):
+        self.config = Config()
+        self.buffer = Buffer(self.config)
+        self.buffer.load_file(filename)
+        self.cursor = Cursor()
+        self.renderer = None
+        self.message = ""
+        self.running = True
+        self.mode = Mode.NORMAL
+        self.prompt = Prompt()
+        self.history = History()
+        self.pending_exit = False
+        self.last_search = ""
+        self.last_found_pos = None
+
+    def _snapshot(self):
+        self.history.push(self.buffer.lines, self.cursor.x, self.cursor.y)
+
+    # ── input routing ─────────────────────────────────────────
+
+    def handle_input(self, key, screen_rows, screen_cols):
+        if self.mode == Mode.SAVE_AS:
+            self._handle_save_as(key)
+        elif self.mode == Mode.SEARCH:
+            self._handle_search(key)
+        elif self.mode == Mode.GOTO_LINE:
+            self._handle_goto_line(key)
+        elif self.mode == Mode.EXIT_CONFIRM:
+            self._handle_exit_confirm(key)
+        else:
+            self._handle_normal(key, screen_rows, screen_cols)
+
+    # ── SAVE AS ───────────────────────────────────────────────
+
+    def _handle_save_as(self, key):
+        result = self.prompt.handle_key(key)
+        if result == 'confirmed':
+            filename = self.prompt.text.strip()
+            if not filename:
+                return
+            self.buffer.filename = filename
+            if self.buffer.save():
+                self.message = f"Saved: {filename}"     # ASCII-safe
+            else:
+                self.message = "Error: could not save file."
+            self._exit_prompt_mode()
+            if self.pending_exit:
+                self.running = False
+        elif result == 'cancelled':
+            self._exit_prompt_mode()
+            self.message = "Save cancelled."
+
+    # ── SEARCH ────────────────────────────────────────────────
+
+    def _handle_search(self, key):
+        result = self.prompt.handle_key(key)
+        if result == 'confirmed':
+            term = self.prompt.text
+            if term:
+                self.last_search = term
+                self._find_text(term)
+            self._exit_prompt_mode()
+        elif result == 'cancelled':
+            self._exit_prompt_mode()
+
+    def _find_text(self, term):
+        if self.last_found_pos == (self.cursor.x, self.cursor.y):
+            start_x = self.cursor.x + 1
+        else:
+            start_x = self.cursor.x
+        result = self.buffer.find_text(term, start_x, self.cursor.y)
+        if result:
+            x, y = result
+            self.cursor.set_pos(x, y, self.buffer.get_line_length,
+                                self.buffer.max_y)
+            self.last_found_pos = (x, y)
+            self.message = f"Found: {term}"
+        else:
+            self.message = f"Not found: {term}"
+            self.last_found_pos = None
+
+    # ── GO TO LINE ────────────────────────────────────────────
+
+    def _handle_goto_line(self, key):
+        result = self.prompt.handle_key(key)
+        if result == 'confirmed':
+            raw = self.prompt.text.strip()
+            try:
+                target = int(raw)
+                target_y = max(0, min(target - 1, self.buffer.max_y))
+                self.cursor.set_pos(0, target_y,
+                                    self.buffer.get_line_length,
+                                    self.buffer.max_y)
+                self.message = f"Line {target_y + 1}/{self.buffer.max_y + 1}"
+            except ValueError:
+                self.message = "Invalid line number."
+            self._exit_prompt_mode()
+        elif result == 'cancelled':
+            self._exit_prompt_mode()
+
+    # ── EXIT CONFIRM ──────────────────────────────────────────
+
+    def _handle_exit_confirm(self, key):
+        if key in (ord('y'), ord('Y')):
+            if self.buffer.filename:
+                if self.buffer.save():
+                    self.running = False
+                else:
+                    self.message = "Error: could not save file."
+                    self.mode = Mode.NORMAL
+            else:
+                self.mode = Mode.SAVE_AS
+                self.prompt.start("Save As: ")
+                self.pending_exit = True
+        elif key in (ord('n'), ord('N')):
+            self.running = False
+        elif key in (ord('c'), ord('C'), Key.CTRL_G, Key.ESCAPE):
+            self.mode = Mode.NORMAL
+            self.message = "Exit cancelled."
+
+    # ── NORMAL mode ───────────────────────────────────────────
+
+    def _handle_normal(self, key, screen_rows, screen_cols):
+        self.message = ""
+        buf = self.buffer
+        cur = self.cursor
+        max_x = buf.get_line_length
+        max_y = buf.max_y
+
+        if key == Key.CTRL_X:
+            if buf.modified:
+                self.mode = Mode.EXIT_CONFIRM
+                self.message = "Save modified buffer?"
+            else:
+                self.running = False
+            return
+        if key == Key.CTRL_S:
+            if buf.filename:
+                if buf.save():
+                    self.message = "File saved."
+                else:
+                    self.message = "Error: could not save file."
+            else:
+                self.mode = Mode.SAVE_AS
+                self.prompt.start("Save As: ")
+            return
+        if key == Key.CTRL_W:
+            self.mode = Mode.SEARCH
+            self.prompt.start("Search: ", self.last_search)
+            return
+        if key == Key.CTRL_T:
+            self.mode = Mode.GOTO_LINE
+            self.prompt.start("Go To Line: ")
+            return
+        if key == Key.CTRL_Z:
+            self._do_undo(); return
+        if key == Key.CTRL_Y:
+            self._do_redo(); return
+
+        if key == Key.CTRL_LEFT:
+            cur.x = buf.get_prev_word_pos(cur.y, cur.x)
+        elif key == Key.CTRL_RIGHT:
+            cur.x = buf.get_next_word_pos(cur.y, cur.x)
+        elif key == Key.PAGE_UP:
+            self._page(-1, screen_rows, screen_cols)
+        elif key == Key.PAGE_DOWN:
+            self._page(1, screen_rows, screen_cols)
+        elif key == Key.HOME or key == Key.CTRL_A:
+            cur.home()
+        elif key == Key.END or key == Key.CTRL_E:
+            cur.end(max_x(cur.y))
+        elif key == Key.ARROW_UP:
+            cur.move(0, -1, max_x, max_y)
+        elif key == Key.ARROW_DOWN:
+            cur.move(0, 1, max_x, max_y)
+        elif key == Key.ARROW_LEFT:
+            if cur.x > 0:
+                cur.x -= 1
+            elif cur.y > 0:
+                cur.y -= 1
+                cur.x = max_x(cur.y)
+        elif key == Key.ARROW_RIGHT:
+            if cur.x < max_x(cur.y):
+                cur.x += 1
+            elif cur.y < max_y:
+                cur.y += 1
+                cur.x = 0
+        elif key == Key.TAB:
+            self._snapshot()
+            cur.x = buf.insert_tab(cur.y, cur.x)
+        elif key == Key.SHIFT_TAB:
+            self._snapshot()
+            cur.x = buf.remove_tab(cur.y, cur.x)
+        elif is_backspace(key):
+            self._snapshot()
+            cur.x, cur.y = buf.backspace(cur.x, cur.y)
+        elif key == Key.DELETE:
+            self._snapshot()
+            buf.delete_char(cur.x, cur.y)
+        elif is_enter(key):
+            self._snapshot()
+            buf.insert_newline(cur.x, cur.y)
+            cur.y += 1
+            cur.x = 0
+        elif 32 <= key <= 126:
+            self._snapshot()
+            buf.insert_char(cur.x, cur.y, chr(key))
+            cur.x += 1
+
+    def _page(self, direction, screen_rows, screen_cols):
+        """Move one viewport up/down, respecting soft wrap."""
+        if self.config.soft_wrap:
+            _, vy = get_visual_position(
+                self.cursor.x, self.cursor.y, self.buffer.lines,
+                screen_cols, True)
+            target = max(0, vy + direction * screen_rows)
+            y = get_logical_from_visual(target, self.buffer.lines,
+                                        screen_cols, True)
+        else:
+            y = self.cursor.y + direction * screen_rows
+        self.cursor.set_pos(self.cursor.x, y,
+                            self.buffer.get_line_length, self.buffer.max_y)
+
+    # ── Undo / Redo ───────────────────────────────────────────
+
+    def _do_undo(self):
+        result = self.history.undo(self.buffer.lines,
+                                   self.cursor.x, self.cursor.y)
+        if result:
+            lines, x, y = result
+            self.buffer.lines = lines
+            self.buffer.modified = True
+            self.cursor.set_pos(x, y, self.buffer.get_line_length,
+                                self.buffer.max_y)
+            self.message = "Undo."
+        else:
+            self.message = "Nothing to undo."
+
+    def _do_redo(self):
+        result = self.history.redo(self.buffer.lines,
+                                   self.cursor.x, self.cursor.y)
+        if result:
+            lines, x, y = result
+            self.buffer.lines = lines
+            self.buffer.modified = True
+            self.cursor.set_pos(x, y, self.buffer.get_line_length,
+                                self.buffer.max_y)
+            self.message = "Redo."
+        else:
+            self.message = "Nothing to redo."
+
+    def _exit_prompt_mode(self):
+        self.prompt.deactivate()
+        self.mode = Mode.NORMAL
+        self.pending_exit = False
+
+    # ── Main loop ─────────────────────────────────────────────
+
+    def main_loop(self, stdscr):
+        _ignore_suspend()
+        self.renderer = Renderer(stdscr, self.config)
+
+        while self.running:
+            screen_rows, screen_cols = self.renderer.get_dimensions()
+
+            vx, vy = get_visual_position(
+                self.cursor.x, self.cursor.y, self.buffer.lines,
+                screen_cols, self.config.soft_wrap)
+            self.cursor.update_scroll(
+                vy, vx, screen_rows, screen_cols,
+                self.config.smooth_scroll_margin, self.config.soft_wrap)
+
+            self.renderer.render(
+                self.buffer, self.cursor, message=self.message,
+                prompt=self.prompt, mode=self.mode,
+            )
+
+            try:
+                key = stdscr.getch()
+            except KeyboardInterrupt:
+                self.running = False
+                break
+
+            if key == Key.RESIZE:
+                continue
+
+            self.handle_input(key, screen_rows, screen_cols)
+
+    def run(self):
+        try:
+            curses.wrapper(self.main_loop)
+        except Exception as e:
+            print(f"Femto crashed: {e}")