Apply clang-tidy suggestions

4 files changed, 102 insertions, 103 deletions

diff --git a/src/keymap/KeySeqParser.cpp b/src/keymap/KeySeqParser.cpp
index c5534eb..f81ba2a 100644
--- a/src/keymap/KeySeqParser.cpp
+++ b/src/keymap/KeySeqParser.cpp
@@ -1,78 +1,78 @@
 #include <QWidget>
 #include <QtCore>
 #include <algorithm>
+#include <cstdint>
 
 #include "keymap/KeySeqParser.hpp"
 
-bool operator==(const KeyChord a, const KeyChord b) {
-  return a.mod == b.mod && a.key == b.key;
+bool operator==(const KeyChord chord1, const KeyChord chord2) {
+  return chord1.mod == chord2.mod && chord1.key == chord2.key;
 }
 
-KeySeqParser::KeySeqParser() {}
-
-QList<KeyChord> KeySeqParser::parse(QString keySequence) {
-  QList<KeyChord> keyChords;
-  KeyChord lastKey;
+QList<KeyChord> KeySeqParser::parse(QString key_sequence) {
+  QList<KeyChord> key_chords;
+  KeyChord last_key;
 
   // TODO: Refactor
   // TODO: Support <C-S-t>
-  keySequence = keySequence.toLower();
-  while (!keySequence.isEmpty()) {
-    int skipCount = 1;
-    if (keySequence.startsWith("<c-")) {
-      int nextClosing = keySequence.indexOf('>');
-      auto keyName = keySequence.sliced(3, nextClosing - 3);
-      lastKey.mod = lastKey.mod | Qt::KeyboardModifier::ControlModifier;
-      lastKey.key = parseKey(keyName);
-      skipCount = nextClosing + 1;
-    } else if (keySequence.startsWith("<s-")) {
-      int nextClosing = keySequence.indexOf('>');
-      auto keyName = keySequence.sliced(3, nextClosing - 3);
-      lastKey.mod = lastKey.mod | Qt::KeyboardModifier::ShiftModifier;
-      lastKey.key = parseKey(keyName);
-      skipCount = nextClosing + 1;
-    } else if (keySequence.startsWith("<")) {
-      int nextClosing = keySequence.indexOf('>');
-      auto keyName = keySequence.sliced(1, nextClosing - 1);
-      lastKey.mod = Qt::KeyboardModifier::NoModifier;
-      lastKey.key = parseKey(keyName);
-      skipCount = nextClosing + 1;
+  key_sequence = key_sequence.toLower();
+  while (!key_sequence.isEmpty()) {
+    int skip_count = 1;
+    uint16_t next_closing;
+    if (key_sequence.startsWith("<c-")) {
+      next_closing = key_sequence.indexOf('>');
+      auto key_name = key_sequence.sliced(3, next_closing - 3);
+      last_key.mod = last_key.mod | Qt::KeyboardModifier::ControlModifier;
+      last_key.key = parse_key(key_name);
+      skip_count = next_closing + 1;
+    } else if (key_sequence.startsWith("<s-")) {
+      next_closing = key_sequence.indexOf('>');
+      auto key_name = key_sequence.sliced(3, next_closing - 3);
+      last_key.mod = last_key.mod | Qt::KeyboardModifier::ShiftModifier;
+      last_key.key = parse_key(key_name);
+      skip_count = next_closing + 1;
+    } else if (key_sequence.startsWith("<")) {
+      next_closing = key_sequence.indexOf('>');
+      auto key_name = key_sequence.sliced(1, next_closing - 1);
+      last_key.mod = Qt::KeyboardModifier::NoModifier;
+      last_key.key = parse_key(key_name);
+      skip_count = next_closing + 1;
     } else {
-      auto keyName = keySequence.first(1);
-      lastKey.mod = Qt::KeyboardModifier::NoModifier;
-      lastKey.key = parseKey(keyName);
+      auto key_name = key_sequence.first(1);
+      last_key.mod = Qt::KeyboardModifier::NoModifier;
+      last_key.key = parse_key(key_name);
     }
 
-    keySequence.slice(std::max(1, skipCount));
-    keyChords.push_back(lastKey);
-    lastKey = KeyChord();
+    key_sequence.slice(std::max(1, skip_count));
+    key_chords.push_back(last_key);
+    last_key = KeyChord();
   }
 
-  return keyChords;
+  return key_chords;
 }
 
-Qt::Key KeySeqParser::parseKey(QString keyName) {
-  if (keyName.length() == 0)
+Qt::Key KeySeqParser::parse_key(const QString &key_name) {
+  if (key_name.length() == 0)
     return Qt::Key_T; // TODO: tmp
 
-  if (keyName.length() == 1) {
-    char c = keyName.toStdString().at(0);
-    return Qt::Key(Qt::Key_A + (c - 'a'));
+  if (key_name.length() == 1) {
+    const char key_char = key_name.toStdString().at(0);
+    return Qt::Key(Qt::Key_A + (key_char - 'a'));
   }
 
-  if (keyName == "space")
+  if (key_name == "space")
     return Qt::Key_Space;
 
-  if (keyName == "cr")
+  if (key_name == "cr")
     return Qt::Key_Return;
 
-  if (keyName == "esc")
+  if (key_name == "esc")
     return Qt::Key_Escape;
 
-  if (keyName == "bs")
+  if (key_name == "bs")
     return Qt::Key_Backspace;
 
-  if (keyName == "tab")
+  if (key_name == "tab")
     return Qt::Key_Tab;
 
   return Qt::Key_T;
diff --git a/src/keymap/KeySeqParser.hpp b/src/keymap/KeySeqParser.hpp
index 2dad0c7..eb878ab 100644
--- a/src/keymap/KeySeqParser.hpp
+++ b/src/keymap/KeySeqParser.hpp
@@ -1,18 +1,17 @@
 #pragma once
 
-#include <QtCore/qnamespace.h>
 #include <QtCore>
-#include <cmath>
+#include <cstdint>
 
 struct KeyChord {
   Qt::KeyboardModifiers mod;
   Qt::Key key;
 };
-bool operator==(const KeyChord a, const KeyChord b);
+bool operator==(KeyChord chord1, KeyChord chord2);
 
-typedef QList<KeyChord> KeySequence;
+using KeySequence = QList<KeyChord>;
 
-enum KeyMatchType {
+enum KeyMatchType : uint8_t {
   NoMatch,
   Match,
   Pending,
@@ -20,8 +19,8 @@ enum KeyMatchType {
 
 class KeySeqParser {
 public:
-  static KeyMatchType keySequenceMatch(const KeySequence target,
-                                       const KeySequence current) {
+  static KeyMatchType key_sequence_match(const KeySequence &target,
+                                         const KeySequence &current) {
     for (int i = 0; i < target.length(); i++) {
       if (current.length() <= i)
         return KeyMatchType::Pending;
@@ -34,11 +33,9 @@ public:
     return KeyMatchType::Match;
   }
 
-public:
-  KeySeqParser();
-
-  KeySequence parse(QString keySequence);
+  KeySeqParser() = default;
+  KeySequence parse(QString key_sequence);
 
 private:
-  Qt::Key parseKey(QString keyName);
+  Qt::Key parse_key(const QString &key_name);
 };
diff --git a/src/keymap/KeymapEvaluator.cpp b/src/keymap/KeymapEvaluator.cpp
index 692317b..912c84d 100644
--- a/src/keymap/KeymapEvaluator.cpp
+++ b/src/keymap/KeymapEvaluator.cpp
@@ -1,20 +1,22 @@
 #include <QWidget>
 #include <QtCore>
+#include <utility>
 
+#include "keymap/KeySeqParser.hpp"
 #include "keymap/KeymapEvaluator.hpp"
 
-KeymapEvaluator::KeymapEvaluator() : QObject() {}
-
 // TODO: Clear mapping after some time
 
-void KeymapEvaluator::addKeymap(KeyMode mode, QString key, KeyAction action) {
-  if (!modalKeys.contains(mode))
-    modalKeys.insert(mode, {});
+void KeymapEvaluator::add_keymap(KeyMode mode, const QString &key,
+                                 KeyAction action) {
+  if (!modal_keys.contains(mode))
+    modal_keys.insert(mode, {});
 
   qDebug() << "    " << mode << key;
 
-  auto keySeq = keySeqParser.parse(key);
-  modalKeys[mode].append(KeyMap{.keySequence = keySeq, .action = action});
+  auto key_seq = key_seq_parser.parse(key);
+  modal_keys[mode].append(
+      KeyMap{.key_sequence = key_seq, .action = std::move(action)});
 }
 
 bool KeymapEvaluator::evaluate(Qt::KeyboardModifiers modifiers, Qt::Key key) {
@@ -22,48 +24,49 @@ bool KeymapEvaluator::evaluate(Qt::KeyboardModifiers modifiers, Qt::Key key) {
       key == Qt::Key_Alt)
     return true;
 
-  auto keymaps = currentModeKeys();
-  auto foundPendingMatches = false;
+  const auto *keymaps = current_mode_keys();
+  auto found_pending_matches = false;
 
-  activeKeySequence.append(KeyChord{.mod = modifiers, .key = key});
+  active_key_sequence.append(KeyChord{.mod = modifiers, .key = key});
 
-  for (auto &keymap : *keymaps) {
-    auto matchType =
-        KeySeqParser::keySequenceMatch(keymap.keySequence, activeKeySequence);
+  for (const auto &keymap : *keymaps) {
+    auto match_type = KeySeqParser::key_sequence_match(keymap.key_sequence,
+                                                       active_key_sequence);
 
-    if (matchType == KeyMatchType::Match) {
+    if (match_type == KeyMatchType::Match) {
       keymap.action();
-      activeKeySequence.clear();
+      active_key_sequence.clear();
       return true;
-    } else if (matchType == KeyMatchType::Pending) {
-      foundPendingMatches = true;
+    }
+    if (match_type == KeyMatchType::Pending) {
+      found_pending_matches = true;
     }
   }
 
-  if (!foundPendingMatches)
-    activeKeySequence.clear();
+  if (!found_pending_matches)
+    active_key_sequence.clear();
 
-  if (isInsertableMode())
-    return foundPendingMatches;
+  if (is_insertable_mode())
+    return found_pending_matches;
 
   return true;
 }
 
-bool KeymapEvaluator::isInsertableMode() {
-  return currentMode == KeyMode::Insert;
+bool KeymapEvaluator::is_insertable_mode() {
+  return current_mode == KeyMode::Insert;
 }
 
-const QList<KeyMap> *KeymapEvaluator::currentModeKeys() {
-  if (!modalKeys.contains(currentMode))
+const QList<KeyMap> *KeymapEvaluator::current_mode_keys() {
+  if (!modal_keys.contains(current_mode))
     return new QList<KeyMap>();
 
-  return &modalKeys[currentMode];
+  return &modal_keys[current_mode];
 }
 
-KeyMode KeymapEvaluator::modeFromString(QString modeString) {
-  if (modeString == "n")
+KeyMode KeymapEvaluator::mode_from_string(const QString &mode_string) {
+  if (mode_string == "n")
     return KeyMode::Normal;
-  if (modeString == "i")
+  if (mode_string == "i")
     return KeyMode::Insert;
   return KeyMode::Normal;
 }
diff --git a/src/keymap/KeymapEvaluator.hpp b/src/keymap/KeymapEvaluator.hpp
index b98a881..4f8184b 100644
--- a/src/keymap/KeymapEvaluator.hpp
+++ b/src/keymap/KeymapEvaluator.hpp
@@ -1,43 +1,42 @@
 #pragma once
 
 #include <QWidget>
-#include <QtCore/qmap.h>
-#include <QtCore/qnamespace.h>
 #include <QtCore>
+#include <cstdint>
 #include <functional>
 
 #include "keymap/KeySeqParser.hpp"
 #include "utils.hpp"
 
-typedef std::function<void()> KeyAction;
+using KeyAction = std::function<void()>;
 
 struct KeyMap {
-  KeySequence keySequence;
+  KeySequence key_sequence;
   KeyAction action;
 };
 
-enum KeyMode { Normal, Insert };
+enum KeyMode : uint8_t { Normal, Insert };
 
 class KeymapEvaluator : public QObject {
   Q_OBJECT
 
 public:
-  KeymapEvaluator();
+  KeymapEvaluator() = default;
 
-  void addKeymap(KeyMode mode, QString key, KeyAction action);
+  void add_keymap(KeyMode mode, const QString &key, KeyAction action);
   bool evaluate(Qt::KeyboardModifiers modifiers, Qt::Key key);
-  KeyMode modeFromString(QString modeString);
+  KeyMode mode_from_string(const QString &mode_string);
 
-  DEFINE_SETTER(setCurrentMode, currentMode)
-  DEFINE_GETTER(getCurrentMode, currentMode)
+  DEFINE_SETTER(set_current_mode, current_mode)
+  DEFINE_GETTER(get_current_mode, current_mode)
 
-private:
-  const QList<KeyMap> *currentModeKeys();
-  bool isInsertableMode();
+protected:
+  const QList<KeyMap> *current_mode_keys();
+  bool is_insertable_mode();
 
 private:
-  QMap<KeyMode, QList<KeyMap>> modalKeys;
-  KeySeqParser keySeqParser;
-  KeyMode currentMode = KeyMode::Normal;
-  KeySequence activeKeySequence;
+  QMap<KeyMode, QList<KeyMap>> modal_keys;
+  KeySeqParser key_seq_parser;
+  KeyMode current_mode = KeyMode::Normal;
+  KeySequence active_key_sequence;
 };