Fix Repl

Author: cmaughan

README.md

@@ -9,6 +9,10 @@
 
 Zep is a simple embeddable editor, with a rendering agnostic design and optional Vim mode.  It is built as a shared modern-cmake library.  The core library is dependency-free (the demo application requires an installed package), and it is possible just to copy the files into your project and build it.  Out of the box Zep can draw to a Qt Widget or an an ImGui window - useful for embedding in a game engine.  A simple syntax highlighting engine is provided, and can easily be extended. Basic theming support is included, and window tabs and vertical/horizontal splits are also available.  Zep is 'opinionated' in how it does things, but is easy to modify and supports many common features.  It is heavliy influenced by Vim, but has a good notepad-style editing mode too.  A simple search feature (Ctrl+P) is a powerful way to find things, and a Repl mode is useful for implementing a console for game scripting.  Intended to eventually sit inside a live-coding environment, Zep also has a minimal mode and several configuration options which can be set in a simple toml-format file.
 
+## Video Overview
+[![Zep Overview](screenshots/video.png)](https://www.youtube.com/watch?v=5u2hjO-7z4M "Zep Overview")
+
+## Screenshot
 ![ImGui](screenshots/sample.png)
 
 Zep supports the standard editing keystrokes you'll find in most editors, along with a reasonable subset of modal Vim editing as an option.  The demo project lets you switch between the editing modes on the fly.  Zep is not meant to replace Vim.  I don't have a lifetime spare to write that, but it has most of the functionality I use day to day, and anything missing gets added over time.  A keymapper enables configuration of Zep outside the standard modes offered.

extensions/repl/mode_repl.cpp

@@ -112,9 +112,13 @@ void ZepReplExCommand::Run(const std::vector<std::string>& tokens)
     }
 
     // TODO: Modifiable but not saveable buffer
-    m_pReplBuffer = GetEditor().GetEmptyBuffer("Repl.lisp");// , FileFlags::ReadOnly);
+    m_pReplBuffer = GetEditor().GetEmptyBuffer("Repl.lisp"); // , FileFlags::ReadOnly);
     m_pReplBuffer->SetBufferType(BufferType::Repl);
     m_pReplBuffer->GetSyntax()->IgnoreLineHighlight();
+    m_pReplBuffer->SetPostKeyNotifier([&](uint32_t key, uint32_t modifier)
+    {
+        return AddKeyPress(key, modifier);
+    });
 
     // Adding the window will make it active and begin the mode
     m_pReplWindow = GetEditor().GetActiveTabWindow()->AddWindow(m_pReplBuffer, nullptr, RegionLayoutType::VBox);
@@ -123,7 +127,7 @@ void ZepReplExCommand::Run(const std::vector<std::string>& tokens)
 
 void ZepReplExCommand::Prompt()
 {
-    // TODO: Repl broken, but when not, need to consider undo 
+    // TODO: Repl broken, but when not, need to consider undo
     ChangeRecord changeRecord;
     m_pReplBuffer->Insert(m_pReplBuffer->End(), PromptString, changeRecord);
     MoveToEnd();
@@ -132,39 +136,24 @@ void ZepReplExCommand::Prompt()
 void ZepReplExCommand::MoveToEnd()
 {
     m_pReplWindow->SetBufferCursor(m_pReplBuffer->End());
-    //m_startLocation = m_pCurrentWindow->GetBufferCursor();
+    m_startLocation = m_pReplWindow->GetBufferCursor();
 }
 
-void ZepReplExCommand::Notify(std::shared_ptr<ZepMessage> message)
-{
 
-    if (message->messageId == Msg::Buffer)
+bool ZepReplExCommand::AddKeyPress(uint32_t key, uint32_t modifiers)
+{
+    (void)&modifiers;
+    if (key == ExtKeys::RETURN)
     {
-        auto spBufferMsg = std::static_pointer_cast<BufferMessage>(message);
-        if (spBufferMsg->pBuffer == m_pReplBuffer)
+        ChangeRecord record;
+        auto& buffer = m_pReplWindow->GetBuffer();
+        std::string str = std::string(buffer.GetGapBuffer().begin() + m_startLocation.Index(), buffer.GetGapBuffer().end());
+        if (str.size() <= 1)
         {
-            // TODO: Reimplement the Repl here.  It used to be a mode, but this way is easier.
-            // Just parse the buffer changes an update the repl; don't need to handle keyboard input.
-            // The code commented below is from the original repl
-            // Note that we know the window, the buffer and the mode.  But we are assuming a single repl.
-            ZLOG(DBG, "Buffer Message");
+            MoveToEnd();
+            buffer.GetMode()->SwitchMode(EditorMode::Insert);
+            return false;
         }
-    }
-}
-
-// TODO: Same keystroke command to close repl?
-
-/*
-void ZepMode_Repl::AddKeyPress(uint32_t key, uint32_t modifiers)
-{
-    // Set the cursor to the end of the buffer while inserting text
-    GetCurrentWindow()->SetBufferCursor(MaxCursorMove);
-
-    else if (key == ExtKeys::RETURN)
-    {
-        auto& buffer = GetCurrentWindow()->GetBuffer();
-        std::string str = std::string(buffer.GetGapBuffer().begin() + m_startLocation, buffer.GetGapBuffer().end());
-        buffer.Insert(buffer.EndLocation(), "\n");
 
         auto stripLineStarts = [](std::string& str) {
             bool newline = true;
@@ -193,36 +182,36 @@ void ZepMode_Repl::AddKeyPress(uint32_t key, uint32_t modifiers)
         stripLineStarts(str);
 
         std::string ret;
-        if (m_pRepl)
+        if (m_pProvider)
         {
             int indent = 0;
-            bool complete = m_pRepl->ReplIsFormComplete(str, indent);
+            bool complete = m_pProvider->ReplIsFormComplete(str, indent);
             if (!complete)
             {
                 // If the indent is < 0, we completed too much of the expression, so don't let the user hit return until they
                 // fix it.  Example in lisp: (+ 2 2))  This expression has 'too many' close brackets.
                 if (indent < 0)
                 {
-                    buffer.Delete(buffer.EndLocation() - 1, buffer.EndLocation());
-                    GetCurrentWindow()->SetBufferCursor(MaxCursorMove);
-                    return;
+                    buffer.Delete(buffer.End() - 1, buffer.End(), record);
+                    m_pReplWindow->SetBufferCursor(buffer.End());
+                    return true;
                 }
 
                 // New line continuation symbol
-                buffer.Insert(buffer.EndLocation(), ContinuationString);
+                buffer.Insert(buffer.End(), ContinuationString, record);
 
                 // Indent by how far the repl suggests
                 if (indent > 0)
                 {
                     for (int i = 0; i < indent; i++)
                     {
-                        buffer.Insert(buffer.EndLocation(), " ");
+                        buffer.Insert(buffer.End(), " ", record);
                     }
                 }
-                GetCurrentWindow()->SetBufferCursor(MaxCursorMove);
-                return;
+                m_pReplWindow->SetBufferCursor(buffer.End());
+                return true;
             }
-            ret = m_pRepl->ReplParse(str);
+            ret = m_pProvider->ReplParse(str);
         }
         else
         {
@@ -232,24 +221,14 @@ void ZepMode_Repl::AddKeyPress(uint32_t key, uint32_t modifiers)
         if (!ret.empty() && ret[0] != 0)
         {
             ret.push_back('\n');
-            buffer.Insert(buffer.EndLocation(), ret);
+            buffer.Insert(buffer.End(), ret, record);
         }
 
         Prompt();
-        return;
-    }
-    else if (key == ExtKeys::BACKSPACE)
-    {
-        auto cursor = GetCurrentWindow()->GetBufferCursor() - 1;
-        if (cursor >= m_startLocation)
-        {
-            GetCurrentWindow()->GetBuffer().Delete(GetCurrentWindow()->GetBufferCursor() - 1, GetCurrentWindow()->GetBufferCursor());
-        }
+        return true;
     }
 
-    return;
+    return false;
 }
 
-*/
-
 } // namespace Zep

extensions/repl/mode_repl.h

@@ -50,11 +50,12 @@ class ZepReplExCommand : public ZepExCommand
 
     static void Register(ZepEditor& editor, IZepReplProvider* pProvider);
 
-    virtual void Notify(std::shared_ptr<ZepMessage> message) override;
     virtual void Run(const std::vector<std::string>& args) override;
     virtual const char* ExCommandName() const override { return "ZRepl"; }
     virtual const KeyMap* GetKeyMappings(ZepMode&) const override { return &m_keymap; }
 
+    virtual bool AddKeyPress(uint32_t key, uint32_t modifiers);
+
 private:
     void Prompt();
     void MoveToEnd();
@@ -64,6 +65,8 @@ class ZepReplExCommand : public ZepExCommand
     ZepBuffer* m_pReplBuffer = nullptr;
     ZepWindow* m_pReplWindow = nullptr;
     KeyMap m_keymap;
+    GlyphIterator m_startLocation;
+    bool m_ignoreMessages = false;
 };
 
 class ZepReplEvaluateOuterCommand : public ZepExCommand

include/zep/buffer.h

@@ -201,6 +201,7 @@ struct ChangeRecord
     }
 };
 
+using fnKeyNotifier = std::function<bool(uint32_t key, uint32_t modifier)>;
 class ZepBuffer : public ZepComponent
 {
 public:
@@ -347,6 +348,10 @@ class ZepBuffer : public ZepComponent
     void ToggleFileFlag(uint32_t flags);
 
     NVec2i GetExpression(ExpressionType type, const GlyphIterator location, const std::vector<char>& beginExpression, const std::vector<char>& endExpression) const;
+    std::string GetBufferText(const GlyphIterator& start, const GlyphIterator& end) const;
+
+    void SetPostKeyNotifier(fnKeyNotifier notifier);
+    fnKeyNotifier GetPostKeyNotifier() const;
 
 private:
     void ClearRangeMarker(std::shared_ptr<RangeMarker> spMarker);
@@ -381,6 +386,7 @@ class ZepBuffer : public ZepComponent
 
     // Modes
     std::shared_ptr<ZepMode> m_spMode;
+    fnKeyNotifier m_postKeyNotifier;
 };
 
 // Notification payload

screenshots/video.png

@@ -983,6 +983,12 @@ void ZepBuffer::UpdateForDelete(const GlyphIterator& startItr, const GlyphIterat
     });
 }
 
+std::string ZepBuffer::GetBufferText(const GlyphIterator& start, const GlyphIterator& end) const
+{
+
+    return std::string(m_gapBuffer.begin() + start.Index(), m_gapBuffer.begin() + end.Index());
+}
+
 void ZepBuffer::UpdateForInsert(const GlyphIterator& startItr, const GlyphIterator& endItr, ChangeRecord& changeRecord)
 {
     ForEachMarker(RangeMarkerType::All, Direction::Forward, startItr, End(), [&](const std::shared_ptr<RangeMarker>& marker) {
@@ -1593,4 +1599,14 @@ GlyphIterator ZepBuffer::Begin() const
     return GlyphIterator(this);
 }
 
+void ZepBuffer::SetPostKeyNotifier(fnKeyNotifier notifier)
+{
+    m_postKeyNotifier = notifier;
+}
+
+fnKeyNotifier ZepBuffer::GetPostKeyNotifier() const
+{
+    return m_postKeyNotifier;
+}
+
 } // namespace Zep

src/buffer.cpp

@@ -389,6 +389,12 @@ void ZepMode::AddKeyPress(uint32_t key, uint32_t modifierKeys)
     // We convert CTRL + f to a string: "<C-f>"
     HandleMappedInput(ConvertInputToMapString(key, modifierKeys));
 
+    auto notifier = m_pCurrentWindow->GetBuffer().GetPostKeyNotifier();
+    if (notifier != nullptr)
+    {
+        notifier(key, modifierKeys);
+    }
+
     timer_restart(m_lastKeyPressTimer);
 }
 
@@ -1987,6 +1993,7 @@ bool ZepMode::HandleExCommand(std::string strCommand)
                 {
                     std::string displayText = reg.second.text;
                     displayText = string_replace(displayText, "\n", "^J");
+                    displayText = string_replace(displayText, "\r", "");
                     str << "\"" << reg.first << "   " << displayText << '\n';
                 }
             }