Better cursor movement

.clang-format

@@ -1,7 +1,8 @@
 ---
-BasedOnStyle: Chromium
 AlignAfterOpenBracket: AlwaysBreak
+AllowShortBlocksOnASingleLine: "Always"
 AllowShortIfStatementsOnASingleLine: WithoutElse
+BasedOnStyle: Chromium
 ColumnLimit: '100'
 ConstructorInitializerAllOnOneLineOrOnePerLine: 'true'
 Cpp11BracedListStyle: 'true'

.github/workflows/main.yml

@@ -11,22 +11,30 @@ jobs:
       - run: sudo apt-get install ninja-build clang-19
       - run: ./run.py
         env:
-          IRIS_CXX_COMPILER: clang++-19
+          CXX: clang++-19
       - uses: pre-commit/action@v3.0.0
-  unit_tests:
+  gcc_unit_tests:
+    runs-on: ubuntu-24.04
+    steps:
+      - uses: actions/checkout@v4
+      - run: sudo apt-get install ninja-build g++-14
+      - run: ./run.py test
+        env:
+          CXX: /usr/bin/g++-14
+  clang_unit_tests:
     runs-on: ubuntu-24.04
     steps:
       - uses: actions/checkout@v4
       - run: sudo apt-get install clang-19
       - run: ./run.py test
         env:
-          IRIS_CXX_COMPILER: clang++-19
+          CXX: clang++-19
   integration_tests:
     runs-on: ubuntu-24.04
     steps:
       - uses: actions/checkout@v4
-      - run: sudo apt-get install clang-19
+      - run: sudo apt-get install ninja-build g++-14
       - run: ./run.py test -I
         env:
+          CXX: /usr/bin/g++-14
           PYTEST_ADDOPTS: "--color=yes"
-          IRIS_CXX_COMPILER: clang++-19

.pre-commit-config.yaml

@@ -13,7 +13,7 @@ repos:
         exclude: "tests/fixture/no_newline_file.txt"
     -   id: trailing-whitespace
   - repo: https://github.com/pre-commit/mirrors-clang-format
-    rev: v21.1.2
+    rev: v21.1.8
     hooks:
       - id: clang-format
         exclude: ".json"
@@ -31,19 +31,28 @@ repos:
     rev: v4.0.0
     hooks:
     - id: add-trailing-comma
+  - repo: https://github.com/hhatto/autopep8
+    rev: v2.3.2
+    hooks:
+      - id: autopep8
+        args: [--in-place, --max-line-length=100]
   - repo: https://github.com/PyCQA/flake8
     rev: 7.3.0
     hooks:
     - id: flake8
   - repo: https://github.com/pre-commit/mirrors-mypy
-    rev: v1.18.2
+    rev: v1.19.1
     hooks:
     - id: mypy
   - repo: https://github.com/rhysd/actionlint
-    rev: v1.7.8
+    rev: v1.7.10
     hooks:
     - id: actionlint
   - repo: https://github.com/sco1/brie-commit
     rev: v1.1.0
     hooks:
     -   id: brie-commit
+  - repo: https://github.com/GideonBear/pre-comet
+    rev: v1.0.0
+    hooks:
+      - id: pre-comet

CHANGELOG.md

@@ -9,9 +9,20 @@
 * Ensure the block cursor is restored when iris is closed
 * Refactored how `;s` works for find and replace
 * Added `;f` command to find a given string further on in the buffer
+* Use `wqa` to save and close all files
+* Iris now handles horizontal scrolling when a line is longer than the screen
+* Pressing backspace at the end of a tab width's worth of whitespace now
+moves back that amount of space
+* Allow for specifying file to save to from command bar
+* `e` key now moves cursor to end of the current word
 
 * Resolved issue with iris crashing after opening an existing file with 0 bytes
 * Resolved issue where filename isn't centered in the status bar
+* Resolved issue with `ctrl+bspace` inserting an `h`
+* Resolved issue where the cursor would stay in the command bar when escaping
+out of it
+* Resolved issue where iris wouldn't resize after SIGCONT if the terminal had
+been resized while backgrounded
 
 ### v0.0.2
 * Added ability to jump to a line number entered as a command: `;42`

CMakeLists.txt

@@ -1,5 +1,4 @@
 cmake_minimum_required(VERSION 3.22.0)
-set(CMAKE_CXX_COMPILER "/usr/bin/clang++")
 project(iris LANGUAGES CXX)
 
 option(RUN_TESTS "Run unit tests" OFF)
@@ -21,7 +20,6 @@ add_compile_options(-Wall)
 add_compile_options(-Wextra)
 add_compile_options(-pedantic)
 add_compile_options(-Wconversion)
-add_compile_options(-Wno-implicit-int-float-conversion)
 add_compile_options(-Wimplicit-fallthrough)
 
 if(ENABLE_ASAN)

README.md

@@ -44,7 +44,8 @@ perform the following actions (alphabetically ordered):
 | <kbd>b</kbd>  | Move cursor back one word                             |
 | <kbd>dl</kbd> | Delete the current line                               |
 | <kbd>dw</kbd> | Delete the current word                               |
-| <kbd>f</kbd>  | Find next entered char ahead in file                  |
+| <kbd>e</kbd>  | Find next entered char ahead in file                  |
+| <kbd>f</kbd>  | Move cursor to end of current word                    |
 | <kbd>F</kbd>  | Find next entered char back in file                   |
 | <kbd>g</kbd>  | Go to top of file                                     |
 | <kbd>G</kbd>  | Go to bottom of file                                  |
@@ -92,6 +93,7 @@ following commands in alphabetical order are available:
 | `;w`               | Save file                                                       |
 | `;wa`              | Save all files                                                  |
 | `;qa`              | Quit all                                                        |
+| `;wqa`             | Write and quit all files                                        |
 
 Search flags for `;s` include:
 * `m` Multiline search

include/README.md

@@ -4,3 +4,10 @@
     - `cmake -S . - B build && cmake --build build`
 - Install it to this repo
     - `cmake --install build --prefix ../iris/include/catch2`
+
+### SPDLOG
+- Clone the git repo: `git@github.com:gabime/spdlog.git` and checkout the git tag
+    - Currently, git commit `32dd298d` is used as the latest tag (v1.16.0) does
+    not work with clang21
+- copy `spdlog/include/spdlog` to `iris/include/spdlog`
+

include/spdlog/async.h

@@ -14,88 +14,86 @@
 // This is because each message in the queue holds a shared_ptr to the
 // originating logger.
 
-#include <functional>
-#include <memory>
-#include <mutex>
-
 #include <spdlog/async_logger.h>
 #include <spdlog/details/registry.h>
 #include <spdlog/details/thread_pool.h>
 
-namespace spdlog {
-
-    namespace details {
-        static const size_t default_async_q_size = 8192;
-    }
-
-    // async logger factory - creates async loggers backed with thread pool.
-    // if a global thread pool doesn't already exist, create it with default queue
-    // size of 8192 items and single thread.
-    template <async_overflow_policy OverflowPolicy = async_overflow_policy::block>
-    struct async_factory_impl {
-        template <typename Sink, typename... SinkArgs>
-        static std::shared_ptr<async_logger> create(std::string logger_name, SinkArgs&&... args) {
-            auto& registry_inst = details::registry::instance();
-
-            // create global thread pool if not already exists..
-
-            auto& mutex = registry_inst.tp_mutex();
-            std::lock_guard<std::recursive_mutex> tp_lock(mutex);
-            auto tp = registry_inst.get_tp();
-            if (tp == nullptr) {
-                tp = std::make_shared<details::thread_pool>(details::default_async_q_size, 1U);
-                registry_inst.set_tp(tp);
-            }
-
-            auto sink = std::make_shared<Sink>(std::forward<SinkArgs>(args)...);
-            auto new_logger = std::make_shared<async_logger>(
-                std::move(logger_name), std::move(sink), std::move(tp), OverflowPolicy);
-            registry_inst.initialize_logger(new_logger);
-            return new_logger;
-        }
-    };
+#include <functional>
+#include <memory>
+#include <mutex>
 
-    using async_factory = async_factory_impl<async_overflow_policy::block>;
-    using async_factory_nonblock = async_factory_impl<async_overflow_policy::overrun_oldest>;
+namespace spdlog {
 
-    template <typename Sink, typename... SinkArgs>
-    inline std::shared_ptr<spdlog::logger> create_async(
-        std::string logger_name,
-        SinkArgs&&... sink_args) {
-        return async_factory::create<Sink>(
-            std::move(logger_name), std::forward<SinkArgs>(sink_args)...);
-    }
+namespace details {
+static const size_t default_async_q_size = 8192;
+}
 
+// async logger factory - creates async loggers backed with thread pool.
+// if a global thread pool doesn't already exist, create it with default queue
+// size of 8192 items and single thread.
+template <async_overflow_policy OverflowPolicy = async_overflow_policy::block>
+struct async_factory_impl {
     template <typename Sink, typename... SinkArgs>
-    inline std::shared_ptr<spdlog::logger> create_async_nb(
-        std::string logger_name,
-        SinkArgs&&... sink_args) {
-        return async_factory_nonblock::create<Sink>(
-            std::move(logger_name), std::forward<SinkArgs>(sink_args)...);
-    }
+    static std::shared_ptr<async_logger> create(std::string logger_name, SinkArgs &&...args) {
+        auto &registry_inst = details::registry::instance();
 
-    // set global thread pool.
-    inline void init_thread_pool(
-        size_t q_size,
-        size_t thread_count,
-        std::function<void()> on_thread_start,
-        std::function<void()> on_thread_stop) {
-        auto tp = std::make_shared<details::thread_pool>(
-            q_size, thread_count, on_thread_start, on_thread_stop);
-        details::registry::instance().set_tp(std::move(tp));
-    }
-
-    inline void
-    init_thread_pool(size_t q_size, size_t thread_count, std::function<void()> on_thread_start) {
-        init_thread_pool(q_size, thread_count, on_thread_start, [] {});
-    }
+        // create global thread pool if not already exists..
 
-    inline void init_thread_pool(size_t q_size, size_t thread_count) {
-        init_thread_pool(q_size, thread_count, [] {}, [] {});
-    }
+        auto &mutex = registry_inst.tp_mutex();
+        std::lock_guard<std::recursive_mutex> tp_lock(mutex);
+        auto tp = registry_inst.get_tp();
+        if (tp == nullptr) {
+            tp = std::make_shared<details::thread_pool>(details::default_async_q_size, 1U);
+            registry_inst.set_tp(tp);
+        }
 
-    // get the global thread pool.
-    inline std::shared_ptr<spdlog::details::thread_pool> thread_pool() {
-        return details::registry::instance().get_tp();
+        auto sink = std::make_shared<Sink>(std::forward<SinkArgs>(args)...);
+        auto new_logger = std::make_shared<async_logger>(std::move(logger_name), std::move(sink),
+                                                         std::move(tp), OverflowPolicy);
+        registry_inst.initialize_logger(new_logger);
+        return new_logger;
     }
+};
+
+using async_factory = async_factory_impl<async_overflow_policy::block>;
+using async_factory_nonblock = async_factory_impl<async_overflow_policy::overrun_oldest>;
+
+template <typename Sink, typename... SinkArgs>
+inline std::shared_ptr<spdlog::logger> create_async(std::string logger_name,
+                                                    SinkArgs &&...sink_args) {
+    return async_factory::create<Sink>(std::move(logger_name),
+                                       std::forward<SinkArgs>(sink_args)...);
+}
+
+template <typename Sink, typename... SinkArgs>
+inline std::shared_ptr<spdlog::logger> create_async_nb(std::string logger_name,
+                                                       SinkArgs &&...sink_args) {
+    return async_factory_nonblock::create<Sink>(std::move(logger_name),
+                                                std::forward<SinkArgs>(sink_args)...);
+}
+
+// set global thread pool.
+inline void init_thread_pool(size_t q_size,
+                             size_t thread_count,
+                             std::function<void()> on_thread_start,
+                             std::function<void()> on_thread_stop) {
+    auto tp = std::make_shared<details::thread_pool>(q_size, thread_count, on_thread_start,
+                                                     on_thread_stop);
+    details::registry::instance().set_tp(std::move(tp));
+}
+
+inline void init_thread_pool(size_t q_size,
+                             size_t thread_count,
+                             std::function<void()> on_thread_start) {
+    init_thread_pool(q_size, thread_count, on_thread_start, [] {});
+}
+
+inline void init_thread_pool(size_t q_size, size_t thread_count) {
+    init_thread_pool(q_size, thread_count, [] {}, [] {});
+}
+
+// get the global thread pool.
+inline std::shared_ptr<spdlog::details::thread_pool> thread_pool() {
+    return details::registry::instance().get_tp();
+}
 }  // namespace spdlog