Generate compile commands for clangd.

CMakeLists.txt

@@ -27,6 +27,8 @@ else()
     ${FTXUI_MICROSOFT_TERMINAL_FALLBACK_HELP_TEXT} OFF)
 endif()
 
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+
 include(cmake/ftxui_message.cmake)
 
 add_library(screen

include/ftxui/component/animation.hpp

@@ -9,9 +9,7 @@
 
 #include "ftxui/component/event.hpp"
 
-namespace ftxui {
-
-namespace animation {
+namespace ftxui::animation {
 // Components who haven't completed their animation can call this function to
 // request a new frame to be drawn later.
 //
@@ -26,7 +24,7 @@ using Duration = std::chrono::duration<float>;
 // Parameter of Component::OnAnimation(param).
 class Params {
  public:
-  Params(Duration duration) : duration_(duration) {}
+  explicit Params(Duration duration) : duration_(duration) {}
 
   /// The duration this animation step represents.
   Duration duration() const { return duration_; }
@@ -93,11 +91,11 @@ float BounceInOut(float p);
 
 class Animator {
  public:
-  Animator(float* from,
-           float to = 0.f,
-           Duration duration = std::chrono::milliseconds(250),
-           easing::Function easing_function = easing::Linear,
-           Duration delay = std::chrono::milliseconds(0));
+  explicit Animator(float* from,
+                    float to = 0.f,
+                    Duration duration = std::chrono::milliseconds(250),
+                    easing::Function easing_function = easing::Linear,
+                    Duration delay = std::chrono::milliseconds(0));
 
   void OnAnimation(Params&);
 
@@ -112,7 +110,6 @@ class Animator {
   Duration current_;
 };
 
-}  // namespace animation
-}  // namespace ftxui
+}  // namespace ftxui::animation
 
 #endif /* end of include guard: FTXUI_ANIMATION_HPP */

include/ftxui/component/captured_mouse.hpp

@@ -9,6 +9,11 @@
 namespace ftxui {
 class CapturedMouseInterface {
  public:
+  CapturedMouseInterface() = default;
+  CapturedMouseInterface(const CapturedMouseInterface&) = default;
+  CapturedMouseInterface(CapturedMouseInterface&&) = delete;
+  CapturedMouseInterface& operator=(const CapturedMouseInterface&) = default;
+  CapturedMouseInterface& operator=(CapturedMouseInterface&&) = delete;
   virtual ~CapturedMouseInterface() = default;
 };
 using CapturedMouse = std::unique_ptr<CapturedMouseInterface>;

include/ftxui/component/component.hpp

@@ -96,9 +96,9 @@ Component Slider(ConstStringRef label,
                  ConstRef<float> increment = 5.f);
 Component Slider(ConstStringRef label,
                  Ref<long> value,
-                 ConstRef<long> min = 0l,
-                 ConstRef<long> max = 100l,
-                 ConstRef<long> increment = 5l);
+                 ConstRef<long> min = 0L,
+                 ConstRef<long> max = 100L,
+                 ConstRef<long> increment = 5L);
 
 Component ResizableSplit(ResizableSplitOption options);
 Component ResizableSplitLeft(Component main, Component back, int* main_size);

include/ftxui/component/component_base.hpp

@@ -29,14 +29,16 @@ using Components = std::vector<Component>;
 /// @ingroup component
 class ComponentBase {
  public:
-  // virtual Destructor.
+  explicit ComponentBase(Components children)
+      : children_(std::move(children)) {}
   virtual ~ComponentBase();
-
   ComponentBase() = default;
 
-  // A component is not copiable.
+  // A component is not copyable/movable.
   ComponentBase(const ComponentBase&) = delete;
-  void operator=(const ComponentBase&) = delete;
+  ComponentBase(ComponentBase&&) = delete;
+  ComponentBase& operator=(const ComponentBase&) = delete;
+  ComponentBase& operator=(ComponentBase&&) = delete;
 
   // Component hierarchy:
   ComponentBase* Parent() const;

include/ftxui/component/loop.hpp

@@ -24,11 +24,14 @@ class Loop {
   void RunOnceBlocking();
   void Run();
 
- private:
-  // This class is non copyable.
+  // This class is non copyable/movable.
+  Loop(const Loop&) = default;
+  Loop(Loop&&) = delete;
+  Loop& operator=(Loop&&) = delete;
   Loop(const ScreenInteractive&) = delete;
   Loop& operator=(const Loop&) = delete;
 
+ private:
   ScreenInteractive* screen_;
   Component component_;
 };

include/ftxui/component/receiver.hpp

@@ -54,14 +54,18 @@ template<class T> Receiver<T> MakeReceiver();
 template <class T>
 class SenderImpl {
  public:
+  SenderImpl(const SenderImpl&) = delete;
+  SenderImpl(SenderImpl&&) = delete;
+  SenderImpl& operator=(const SenderImpl&) = delete;
+  SenderImpl& operator=(SenderImpl&&) = delete;
   void Send(T t) { receiver_->Receive(std::move(t)); }
   ~SenderImpl() { receiver_->ReleaseSender(); }
 
   Sender<T> Clone() { return receiver_->MakeSender(); }
 
  private:
   friend class ReceiverImpl<T>;
-  SenderImpl(ReceiverImpl<T>* consumer) : receiver_(consumer) {}
+  explicit SenderImpl(ReceiverImpl<T>* consumer) : receiver_(consumer) {}
   ReceiverImpl<T>* receiver_;
 };
 
@@ -73,15 +77,17 @@ class ReceiverImpl {
     senders_++;
     return std::unique_ptr<SenderImpl<T>>(new SenderImpl<T>(this));
   }
-  ReceiverImpl() { senders_ = 0; }
+  ReceiverImpl() = default;
 
   bool Receive(T* t) {
     while (senders_ || !queue_.empty()) {
       std::unique_lock<std::mutex> lock(mutex_);
-      if (queue_.empty())
+      if (queue_.empty()) {
         notifier_.wait(lock);
-      if (queue_.empty())
+      }
+      if (queue_.empty()) {
         continue;
+      }
       *t = std::move(queue_.front());
       queue_.pop();
       return true;
@@ -91,8 +97,9 @@ class ReceiverImpl {
 
   bool ReceiveNonBlocking(T* t) {
     std::unique_lock<std::mutex> lock(mutex_);
-    if (queue_.empty())
+    if (queue_.empty()) {
       return false;
+    }
     *t = queue_.front();
     queue_.pop();
     return true;
@@ -127,7 +134,7 @@ class ReceiverImpl {
   std::mutex mutex_;
   std::queue<T> queue_;
   std::condition_variable notifier_;
-  std::atomic<int> senders_;
+  std::atomic<int> senders_{0};
 };
 
 template <class T>

include/ftxui/dom/elements.hpp

@@ -80,9 +80,7 @@ Decorator borderStyled(BorderStyle);
 Decorator borderStyled(BorderStyle, Color);
 Decorator borderStyled(Color);
 Decorator borderWith(const Pixel&);
-Element window(Element title,
-               Element content,
-               BorderStyle border = ROUNDED);
+Element window(Element title, Element content, BorderStyle border = ROUNDED);
 Element spinner(int charset_index, size_t image_index);
 Element paragraph(const std::string& text);
 Element paragraphAlignLeft(const std::string& text);

include/ftxui/dom/node.hpp

@@ -22,7 +22,7 @@ using Elements = std::vector<Element>;
 class Node {
  public:
   Node();
-  Node(Elements children);
+  explicit Node(Elements children);
   Node(const Node&) = delete;
   Node(const Node&&) = delete;
   Node& operator=(const Node&) = delete;

include/ftxui/dom/table.hpp

@@ -37,8 +37,8 @@ class TableSelection;
 class Table {
  public:
   Table();
-  Table(std::vector<std::vector<std::string>>);
-  Table(std::vector<std::vector<Element>>);
+  explicit Table(std::vector<std::vector<std::string>>);
+  explicit Table(std::vector<std::vector<Element>>);
   TableSelection SelectAll();
   TableSelection SelectCell(int column, int row);
   TableSelection SelectRow(int row_index);

include/ftxui/dom/take_any_args.hpp

@@ -5,6 +5,7 @@
 #define FTXUI_DOM_TAKE_ANY_ARGS_HPP
 
 // IWYU pragma: private, include "ftxui/dom/elements.hpp"
+#include <ftxui/dom/node.hpp>
 #include <type_traits>
 
 namespace ftxui {
@@ -19,8 +20,9 @@ inline void Merge(Elements& container, Element element) {
 
 template <>
 inline void Merge(Elements& container, Elements elements) {
-  for (auto& element : elements)
+  for (auto& element : elements) {
     container.push_back(std::move(element));
+  }
 }
 
 // Turn a set of arguments into a vector.

include/ftxui/screen/color.hpp

@@ -24,10 +24,12 @@ class Color {
   enum Palette16 : uint8_t;
   enum Palette256 : uint8_t;
 
+  // NOLINTBEGIN
   Color();                  // Transparent.
   Color(Palette1 index);    // Transparent.
   Color(Palette16 index);   // Implicit conversion from index to Color.
   Color(Palette256 index);  // Implicit conversion from index to Color.
+  // NOLINTEND
   Color(uint8_t red, uint8_t green, uint8_t blue);
   static Color RGB(uint8_t red, uint8_t green, uint8_t blue);
   static Color HSV(uint8_t hue, uint8_t saturation, uint8_t value);

include/ftxui/screen/string.hpp

@@ -4,10 +4,10 @@
 #ifndef FTXUI_SCREEN_STRING_HPP
 #define FTXUI_SCREEN_STRING_HPP
 
-#include <stddef.h>  // for size_t
-#include <cstdint>   // for uint8_t
-#include <string>    // for string, wstring, to_string
-#include <vector>    // for vector
+#include <cstddef>  // for size_t
+#include <cstdint>  // for uint8_t
+#include <string>   // for string, wstring, to_string
+#include <vector>   // for vector
 
 namespace ftxui {
 std::string to_string(const std::wstring& s);

include/ftxui/util/autoreset.hpp

@@ -16,6 +16,10 @@ class AutoReset {
       : variable_(variable), previous_value_(std::move(*variable)) {
     *variable_ = std::move(new_value);
   }
+  AutoReset(const AutoReset&) = delete;
+  AutoReset(AutoReset&&) = delete;
+  AutoReset& operator=(const AutoReset&) = delete;
+  AutoReset& operator=(AutoReset&&) = delete;
   ~AutoReset() { *variable_ = std::move(previous_value_); }
 
  private:

include/ftxui/util/ref.hpp

@@ -15,10 +15,12 @@ template <typename T>
 class ConstRef {
  public:
   ConstRef() = default;
+  ConstRef(T t) : variant_(std::move(t)) {}  // NOLINT
+  ConstRef(const T* t) : variant_(t) {}      // NOLINT
+  ConstRef& operator=(ConstRef&&) noexcept = default;
   ConstRef(const ConstRef<T>&) = default;
-  ConstRef(ConstRef<T>&&) = default;
-  ConstRef(T t) : variant_(std::move(t)) {}
-  ConstRef(const T* t) : variant_(t) {}
+  ConstRef(ConstRef<T>&&) noexcept = default;
+  ~ConstRef() = default;
 
   // Make a "reseatable" reference
   ConstRef<T>& operator=(const ConstRef<T>&) = default;
@@ -42,10 +44,12 @@ template <typename T>
 class Ref {
  public:
   Ref() = default;
+  Ref(T t) : variant_(std::move(t)) {}  // NOLINT
+  Ref(T* t) : variant_(t) {}            // NOLINT
+  ~Ref() = default;
+  Ref& operator=(Ref&&) noexcept = default;
   Ref(const Ref<T>&) = default;
-  Ref(Ref<T>&&) = default;
-  Ref(T t) : variant_(std::move(t)) {}
-  Ref(T* t) : variant_(t) {}
+  Ref(Ref<T>&&) noexcept = default;
 
   // Make a "reseatable" reference.
   Ref<T>& operator=(const Ref<T>&) = default;
@@ -77,8 +81,10 @@ class StringRef : public Ref<std::string> {
  public:
   using Ref<std::string>::Ref;
 
-  StringRef(const wchar_t* ref) : StringRef(to_string(std::wstring(ref))) {}
-  StringRef(const char* ref) : StringRef(std::string(ref)) {}
+  StringRef(const wchar_t* ref)  // NOLINT
+      : StringRef(to_string(std::wstring(ref))) {}
+  StringRef(const char* ref)  // NOLINT
+      : StringRef(std::string(ref)) {}
 };
 
 /// @brief An adapter. Own or reference a constant string. For convenience, this
@@ -87,19 +93,27 @@ class ConstStringRef : public ConstRef<std::string> {
  public:
   using ConstRef<std::string>::ConstRef;
 
-  ConstStringRef(const std::wstring* ref) : ConstStringRef(to_string(*ref)) {}
-  ConstStringRef(const std::wstring ref) : ConstStringRef(to_string(ref)) {}
-  ConstStringRef(const wchar_t* ref)
+  ConstStringRef(const std::wstring* ref)  // NOLINT
+      : ConstStringRef(to_string(*ref)) {}
+  ConstStringRef(const std::wstring ref)  // NOLINT
+      : ConstStringRef(to_string(ref)) {}
+  ConstStringRef(const wchar_t* ref)  // NOLINT
       : ConstStringRef(to_string(std::wstring(ref))) {}
-  ConstStringRef(const char* ref) : ConstStringRef(std::string(ref)) {}
+  ConstStringRef(const char* ref)  // NOLINT
+      : ConstStringRef(std::string(ref)) {}
 };
 
 /// @brief An adapter. Reference a list of strings.
 class ConstStringListRef {
  public:
   ConstStringListRef() = default;
-  ConstStringListRef(const std::vector<std::string>* ref) : ref_(ref) {}
-  ConstStringListRef(const std::vector<std::wstring>* ref) : ref_wide_(ref) {}
+  ~ConstStringListRef() = default;
+  ConstStringListRef(ConstStringListRef&&) = delete;
+  ConstStringListRef& operator=(ConstStringListRef&&) = delete;
+  ConstStringListRef(const std::vector<std::string>* ref)  // NOLINT
+      : ref_(ref) {}
+  ConstStringListRef(const std::vector<std::wstring>* ref)  // NOLINT
+      : ref_wide_(ref) {}
   ConstStringListRef(const ConstStringListRef& other) = default;
   ConstStringListRef& operator=(const ConstStringListRef& other) = default;
 

src/ftxui/component/component_fuzzer.cpp

@@ -11,8 +11,9 @@ using namespace ftxui;
 namespace {
 
 bool GeneratorBool(const char*& data, size_t& size) {
-  if (size == 0)
+  if (size == 0) {
     return false;
+  }
 
   auto out = bool(data[0] % 2);
   data++;

src/ftxui/dom/box_helper.hpp

@@ -6,8 +6,7 @@
 
 #include <vector>
 
-namespace ftxui {
-namespace box_helper {
+namespace ftxui::box_helper {
 
 struct Element {
   // Input:
@@ -21,7 +20,6 @@ struct Element {
 
 void Compute(std::vector<Element>* elements, int target_size);
 
-}  // namespace box_helper
-}  // namespace ftxui
+}  // namespace ftxui::box_helper
 
 #endif /* end of include guard: FTXUI_DOM_BOX_HELPER_HPP */

src/ftxui/dom/flexbox_helper.hpp

@@ -7,8 +7,7 @@
 #include <vector>
 #include "ftxui/dom/flexbox_config.hpp"
 
-namespace ftxui {
-namespace flexbox_helper {
+namespace ftxui::flexbox_helper {
 
 struct Block {
   // Input:
@@ -38,7 +37,6 @@ struct Global {
 
 void Compute(Global& global);
 
-}  // namespace flexbox_helper
-}  // namespace ftxui
+}  // namespace ftxui::flexbox_helper
 
 #endif /* end of include guard: FTXUI_DOM_FLEXBOX_HELPER_HPP*/