Add an in-tree Conan recipe, tested by CI

FTXUI is currently only consumable via Conan through the community-maintained
recipe on Conan Center, which lags behind releases. This adds a conanfile.py
at the repository root wrapping the existing CMake install, plus a
test_package smoke test and a GitHub Actions workflow (Linux/macOS/Windows,
static/shared) that runs `conan create .` on every push and PR.

Related to #1296

Author: ArthurSonzogni

.github/workflows/conan.yaml

@@ -0,0 +1,43 @@
+name: Conan
+
+on:
+  # On new commits to main:
+  push:
+    branches:
+      - main
+
+  # On pull requests:
+  pull_request:
+    branches:
+      - main
+
+jobs:
+  test_conan:
+    name: "Conan, ${{ matrix.os }}, shared=${{ matrix.shared }}"
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+        shared: [false, true]
+
+    runs-on: ${{ matrix.os }}
+    steps:
+      - name: "Checkout repository"
+        uses: actions/checkout@v4
+
+      - name: "Setup Python"
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.x'
+
+      - name: "Install Conan"
+        run: pip install conan
+
+      - name: "Detect Conan profile"
+        run: conan profile detect
+
+      - name: "conan create ."
+        run: >
+          conan create .
+          --build=missing
+          -o "&:shared=${{ matrix.shared }}"

.gitignore

@@ -13,6 +13,7 @@ out/
 !.gitignore
 !CHANGELOG.md
 !CMakeLists.txt
+!conanfile.py
 !LICENSE
 !README.md
 !GEMINI.md
@@ -84,6 +85,11 @@ out/
 /subprojects/*
 !subprojects/*.wrap
 
+# test_package directory (Conan recipe self-test):
+!test_package/**/*.py
+!test_package/**/*.txt
+!test_package/**/*.cpp
+
 # tools directory:
 !tools/**/*.sh
 !tools/**/*.py

conanfile.py

@@ -0,0 +1,96 @@
+import os
+import re
+
+from conan import ConanFile
+from conan.tools.cmake import CMake, CMakeToolchain, cmake_layout
+from conan.tools.files import copy, load, rmdir
+
+required_conan_version = ">=2.0.0"
+
+
+class FtxuiConan(ConanFile):
+    name = "ftxui"
+    description = "C++ Functional Terminal User Interface."
+    license = "MIT"
+    url = "https://github.com/ArthurSonzogni/FTXUI"
+    homepage = "https://github.com/ArthurSonzogni/FTXUI"
+    topics = ("terminal", "tui", "cli", "console", "functional")
+    package_type = "library"
+    settings = "os", "arch", "compiler", "build_type"
+    options = {
+        "shared": [True, False],
+        "fPIC": [True, False],
+    }
+    default_options = {
+        "shared": False,
+        "fPIC": True,
+    }
+
+    exports_sources = (
+        "CMakeLists.txt",
+        "cmake/*",
+        "include/*",
+        "src/*",
+        "ftxui.pc.in",
+        "LICENSE",
+        # CMakeLists.txt unconditionally add_subdirectory()s these two
+        # directories; each one's own CMakeLists.txt returns immediately
+        # when its FTXUI_BUILD_* option is off, so nothing else from
+        # examples/ or doc/ needs to be exported.
+        "examples/CMakeLists.txt",
+        "doc/CMakeLists.txt",
+    )
+
+    def set_version(self):
+        cmake_lists = load(self, os.path.join(self.recipe_folder, "CMakeLists.txt"))
+        match = re.search(r"project\(\s*ftxui.*?VERSION\s+(\S+)", cmake_lists, re.DOTALL)
+        self.version = match.group(1)
+
+    def config_options(self):
+        if self.settings.os == "Windows":
+            self.options.rm_safe("fPIC")
+
+    def configure(self):
+        if self.options.shared:
+            self.options.rm_safe("fPIC")
+
+    def layout(self):
+        cmake_layout(self, src_folder=".")
+
+    def generate(self):
+        tc = CMakeToolchain(self)
+        tc.variables["BUILD_SHARED_LIBS"] = bool(self.options.shared)
+        tc.variables["FTXUI_BUILD_DOCS"] = False
+        tc.variables["FTXUI_BUILD_EXAMPLES"] = False
+        tc.variables["FTXUI_BUILD_MODULES"] = False
+        tc.variables["FTXUI_BUILD_TESTS"] = False
+        tc.variables["FTXUI_BUILD_TESTS_FUZZER"] = False
+        tc.variables["FTXUI_ENABLE_INSTALL"] = True
+        tc.variables["FTXUI_QUIET"] = True
+        tc.generate()
+
+    def build(self):
+        cmake = CMake(self)
+        cmake.configure()
+        cmake.build()
+
+    def package(self):
+        copy(self, "LICENSE", src=self.source_folder, dst=os.path.join(self.package_folder, "licenses"))
+        cmake = CMake(self)
+        cmake.install()
+        rmdir(self, os.path.join(self.package_folder, "lib", "cmake"))
+        rmdir(self, os.path.join(self.package_folder, "lib", "pkgconfig"))
+
+    def package_info(self):
+        self.cpp_info.set_property("cmake_file_name", "ftxui")
+
+        self.cpp_info.components["screen"].set_property("cmake_target_name", "ftxui::screen")
+        self.cpp_info.components["screen"].libs = ["ftxui-screen"]
+
+        self.cpp_info.components["dom"].set_property("cmake_target_name", "ftxui::dom")
+        self.cpp_info.components["dom"].libs = ["ftxui-dom"]
+        self.cpp_info.components["dom"].requires = ["screen"]
+
+        self.cpp_info.components["component"].set_property("cmake_target_name", "ftxui::component")
+        self.cpp_info.components["component"].libs = ["ftxui-component"]
+        self.cpp_info.components["component"].requires = ["dom"]

doc/installation_conan.md

@@ -26,6 +26,12 @@ After ensuring your environment is set up correctly, create a Conan configuratio
 > team but by the community. The package maintainer appears to actively update it
 > to the latest releases. Many thanks to the maintainer for their work!
 
+FTXUI also ships its own `conanfile.py` at the root of the repository, tested
+by CI on every commit. It isn't published to Conan Center itself, but it can
+be used to consume FTXUI directly from a local checkout via
+`conan create .`, and could serve as the basis for an official Conan Center
+recipe.
+
 @todo If you are familiar with the process, please consider adding an "official" build script to Conan Center.
 This could be a GitHub Action that automatically updates Conan Center upon new releases.
 

test_package/CMakeLists.txt

@@ -0,0 +1,8 @@
+cmake_minimum_required(VERSION 3.15)
+project(test_package CXX)
+
+find_package(ftxui CONFIG REQUIRED)
+
+add_executable(example src/example.cpp)
+target_compile_features(example PRIVATE cxx_std_17)
+target_link_libraries(example PRIVATE ftxui::component)

test_package/conanfile.py

@@ -0,0 +1,30 @@
+import os
+
+from conan import ConanFile
+from conan.tools.build import can_run
+from conan.tools.cmake import CMake, CMakeToolchain, cmake_layout
+
+
+class FtxuiTestConan(ConanFile):
+    settings = "os", "arch", "compiler", "build_type"
+    generators = "CMakeDeps"
+
+    def requirements(self):
+        self.requires(self.tested_reference_str)
+
+    def layout(self):
+        cmake_layout(self)
+
+    def generate(self):
+        tc = CMakeToolchain(self)
+        tc.generate()
+
+    def build(self):
+        cmake = CMake(self)
+        cmake.configure()
+        cmake.build()
+
+    def test(self):
+        if can_run(self):
+            bin_path = os.path.join(self.cpp.build.bindir, "example")
+            self.run(bin_path, env="conanrun")

test_package/src/example.cpp

@@ -0,0 +1,16 @@
+#include <ftxui/dom/elements.hpp>
+#include <ftxui/screen/screen.hpp>
+#include <iostream>
+
+int main() {
+  using namespace ftxui;
+  auto document = hbox({
+      text(" Hello "),
+      text("FTXUI ") | bold | color(Color::Red),
+      text(" world! "),
+  });
+  auto screen = Screen::Create(Dimension::Full(), Dimension::Fit(document));
+  Render(screen, document);
+  std::cout << screen.ToString() << std::endl;
+  return 0;
+}