Prepare release (#18)

- rename folder
- adjust external usable CMake variables
- use consistent nameing (sl3 instead of libsl3)
- update docs
- test that repo can be consumed via fetch content

Author: a4z

.github/workflows/build-internal-sqlite.yml

@@ -37,7 +37,7 @@ jobs:
       if: startsWith(matrix.build.os, 'windows')
       uses: ilammy/msvc-dev-cmd@v1
     - name: Configure project
-      run:  cmake --preset ${{ matrix.build.preset }} -DPROJECT_ADDONS='add-on/fetch-dependencies' -DUSE_INTERNAL_SQLITE3=ON
+      run:  cmake --preset ${{ matrix.build.preset }} -DPROJECT_ADDONS='add-on/fetch-dependencies' -Dsl3_USE_INTERNAL_SQLITE3=ON
     - name: Build project
       run:  cmake --build --preset ${{ matrix.build.preset }}-release --parallel --verbose
     - name: Run unit test

CMake/lib/libsl3Config.cmake.in

@@ -22,25 +22,24 @@ project(libsl3
 
 
 
-find_package(commonCompilerWarnings CONFIG REQUIRED)
-#find_package(sqlite CONFIG REQUIRED)
-
-
-# is in toolchain file now
-# set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
-
 # done differently now
-LIST(PREPEND CMAKE_MODULE_PATH "${libsl3_SOURCE_DIR}/cmake/lib")
+LIST(PREPEND CMAKE_MODULE_PATH "${libsl3_SOURCE_DIR}/cmake")
 
 #optional enable personal test/trial dir
 include(CMakeLocalOpts.cmake OPTIONAL)
 
 
-SET (USE_INTERNAL_SQLITE3 FALSE CACHE BOOL
-    "use build-in sqlite3 ON, use system sqlite3 header/lib, OFF" )
+option(sl3_USE_INTERNAL_SQLITE3 "use build-in sqlite3 ON, use system sqlite3 header/lib, OFF" OFF)
+option(sl3_USE_COMMON_COMPILER_WARNINGS "Build using shared libraries" ON)
 
-# TODO, reactivate that
-#include( setup_doc )
+if (sl3_USE_COMMON_COMPILER_WARNINGS)
+    find_package(commonCompilerWarnings CONFIG REQUIRED)
+    set(LIBWARNINGS a4z::commonCompilerWarnings)
+else(sl3_USE_COMMON_COMPILER_WARNINGS)
+    add_library(all_warnings_off INTERFACE)
+    set(LIBWARNINGS all_warnings_off)
+    message(STATUS "sl3_USE_COMMON_COMPILER_WARNINGS is OFF")
+endif(sl3_USE_COMMON_COMPILER_WARNINGS)
 
 
 set(sl3_CONFIG_HEADER "${CMAKE_CURRENT_SOURCE_DIR}/include/sl3/config.hpp")
@@ -90,18 +89,7 @@ target_include_directories(sl3 PUBLIC
   $<INSTALL_INTERFACE:include>  # <prefix>/include/mylib
 )
 
-# TODO, make this only when a top level project
-target_link_libraries(sl3 PRIVATE $<BUILD_INTERFACE:a4z::commonCompilerWarnings>)
-
-# if (USE_INTERNAL_SQLITE3)
-#     include( sqlite/setup_sqlite3.cmake )
-# else(USE_INTERNAL_SQLITE3)
-#     find_package(SQLite3 REQUIRED)
-#     # target_link_libraries(sl3 PUBLIC ${SQLite3_LIBRARIES})
-#     # target_include_directories(sl3 SYSTEM BEFORE PRIVATE ${SQLite3_INCLUDE_DIRS})
-#     # target_link_libraries(sl3 PUBLIC SQLite::SQLite3)
-# endif(USE_INTERNAL_SQLITE3)
-
+target_link_libraries(sl3 PRIVATE $<BUILD_INTERFACE:${LIBWARNINGS}>)
 
 include( lib/find_sqlite )
 target_link_libraries(sl3 PUBLIC ${SQLITE_LINK_NAME})
@@ -118,16 +106,14 @@ if(BUILD_SHARED_LIBS)
     )
 endif(BUILD_SHARED_LIBS)
 
-if(BUILD_TESTING)
+if(sl3_BUILD_TESTING)
     add_subdirectory(tests)
-endif(BUILD_TESTING)
+endif(sl3_BUILD_TESTING)
 
 include(lib/install)
-
 include(lib/doxydoc)
 
-include(CMakePrintSystemInformation)
-
-include(CMakePrintHelpers)
-cmake_print_variables(CMAKE_SYSTEM_AND_CXX_COMPILER_INFO_FILE)
+# include(CMakePrintSystemInformation)
+# include(CMakePrintHelpers)
+# cmake_print_variables(CMAKE_SYSTEM_AND_CXX_COMPILER_INFO_FILE)
 

CMakeLists.txt

@@ -1,9 +1,9 @@
 {
   "version": 8,
   "include": [
-      "CMake/preset/ninja.json",
-      "CMake/preset/xcode.json",
-      "CMake/preset/msvc22.json"
+      "cmake/preset/ninja.json",
+      "cmake/preset/xcode.json",
+      "cmake/preset/msvc22.json"
   ]
 }
 

CMakePresets.json

@@ -13,6 +13,28 @@ For people seeking the old version, release v1.1.31001 preserves the original C+
 **The full documentation for libsl3 can be found here:** <br>
 https://a4z.github.io/libsl3/
 
+## Build
+
+Quickly summarized, there are dependencies, but they are all either development dependencies or optional
+
+- sqlite3
+- doctest
+- commonCompilerWarnings
+
+### Consume via CMake
+
+To build libsl3 without any dependencies, run
+
+    cmake -S . -B build -DBUILD_TESTING=OFF -Dsl3_USE_INTERNAL_SQLITE3=ON -Dsl3_USE_COMMON_COMPILER_WARNINGS=OFF
+
+This will build libsl3 with the internal sqlite distribution.
+
+For using sqlite from the system, run
+
+    cmake -S . -B build -DBUILD_TESTING=OFF -Dsl3_USE_COMMON_COMPILER_WARNINGS=OFF
+
+For more information, visit the documentation. (TODO, link)
+
 ## A short usage example
 
 ```cpp

README.md

@@ -45,17 +45,17 @@ Or someone whats to rely whats on the system (root fs on x compile for yocto)
 include(lib/debug)
 #print_all_variables()
 
-if (USE_INTERNAL_SQLITE3)
+if (sl3_USE_INTERNAL_SQLITE3)
     include( sqlite/setup_sqlite3.cmake )
-else(USE_INTERNAL_SQLITE3)
+else(sl3_USE_INTERNAL_SQLITE3)
   if (_VCPKG_INSTALLED_DIR)
     find_package(unofficial-sqlite3 REQUIRED)
     set(SQLITE_LINK_NAME unofficial::sqlite3::sqlite3)
   else()
     find_package(SQLite3 REQUIRED)
     set(SQLITE_LINK_NAME SQLite::SQLite3)
   endif()
-endif(USE_INTERNAL_SQLITE3)
+endif(sl3_USE_INTERNAL_SQLITE3)
 
 # print_variable(SQLite3_INCLUDE_DIR)
 # print_variable(SQLite3_LIBRARY)

CMake/add-on/coverage-clang.cmake renamed to cmake/add-on/coverage-clang.cmake

@@ -2,31 +2,31 @@ include_guard(GLOBAL)
 
 include(GNUInstallDirs)
 
-install(TARGETS sl3 EXPORT libsl3Targets)
+install(TARGETS sl3 EXPORT sl3Targets)
 INSTALL(FILES ${sl3_HDR} DESTINATION include/sl3)
 INSTALL(FILES include/sl3.hpp DESTINATION include/sl3)
 
-install(EXPORT libsl3Targets
-    FILE libsl3Targets.cmake
+install(EXPORT sl3Targets
+    FILE sl3Targets.cmake
     NAMESPACE a4z::
     DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}"
 )
 
 include(CMakePackageConfigHelpers)
 write_basic_package_version_file(
-    ${CMAKE_CURRENT_BINARY_DIR}/libsl3ConfigVersion.cmake
+    ${CMAKE_CURRENT_BINARY_DIR}/sl3ConfigVersion.cmake
     COMPATIBILITY AnyNewerVersion
 )
 configure_package_config_file(
-    ${CMAKE_CURRENT_LIST_DIR}/libsl3Config.cmake.in
-    ${CMAKE_CURRENT_BINARY_DIR}/libsl3Config.cmake
+    ${CMAKE_CURRENT_LIST_DIR}/sl3Config.cmake.in
+    ${CMAKE_CURRENT_BINARY_DIR}/sl3Config.cmake
     INSTALL_DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}"
 )
 
 install(
     FILES
-        ${CMAKE_CURRENT_BINARY_DIR}/libsl3Config.cmake
-        ${CMAKE_CURRENT_BINARY_DIR}/libsl3ConfigVersion.cmake
+        ${CMAKE_CURRENT_BINARY_DIR}/sl3Config.cmake
+        ${CMAKE_CURRENT_BINARY_DIR}/sl3ConfigVersion.cmake
     DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}"
 
 )

CMake/add-on/coverage-gcov.cmake renamed to cmake/add-on/coverage-gcov.cmake

@@ -0,0 +1,2 @@
+include_guard(GLOBAL)
+

CMake/add-on/coverage-report-clang.sh renamed to cmake/add-on/coverage-report-clang.sh

@@ -0,0 +1,5 @@
+@PACKAGE_INIT@
+
+include("${CMAKE_CURRENT_LIST_DIR}/sl3Targets.cmake")
+
+check_required_components("sl3")

CMake/add-on/fetch-dependencies.cmake renamed to cmake/add-on/fetch-dependencies.cmake

@@ -22,11 +22,13 @@ function (add_doctest NAME)
 
     add_executable(sl3test-${NAME} ${D_TEST_SOURCES} $<TARGET_OBJECTS:doctest_main>)
     # use naming what we had for now
-    target_link_libraries(sl3test-${NAME} PRIVATE sl3 ${CON_DOCTEST}
-       # a4z::commonCompilerWarnings
-    # "$<BUILD_INTERFACE:a4z:commonCompilerWarnings>"
+    target_link_libraries(sl3test-${NAME}
+        PRIVATE
+            sl3
+            ${CON_DOCTEST}
+            $<BUILD_INTERFACE:${LIBWARNINGS}>
     )
-    target_link_libraries(sl3test-${NAME} PRIVATE $<BUILD_INTERFACE:a4z::commonCompilerWarnings>)
+    #target_link_libraries(sl3test-${NAME} PRIVATE $<BUILD_INTERFACE:a4z::commonCompilerWarnings>)
 
     if(NOT D_TEST_TIMEOUT)
         set(D_TEST_TIMEOUT 3)

CMake/lib/debug.cmake renamed to cmake/lib/debug.cmake

@@ -10,7 +10,7 @@
       "cacheVariables": {
         "CMAKE_COMPILE_WARNING_AS_ERROR": "ON",
         "ACTIVE_PRESET_NAME": "${presetName}",
-        "CMAKE_MODULE_PATH": "${sourceDir}/CMake",
+        "CMAKE_MODULE_PATH": "${sourceDir}/cmake",
         "CMAKE_PROJECT_INCLUDE": "project-setup"
       },
       "environment": {

CMake/lib/doxydoc.cmake renamed to cmake/lib/doxydoc.cmake

@@ -13,10 +13,8 @@ set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 if(PROJECT_IS_TOP_LEVEL)
     # make git ignore the build directory
     file(WRITE ${CMAKE_BINARY_DIR}/.gitignore "*")
-    # set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin )
-    # set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib )
-    # set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib )
     include(CTest)
+    option(sl3_BUILD_TESTING "Build the tests" ${BUILD_TESTING})
 endif()
 
 

CMake/lib/find_sqlite.cmake renamed to cmake/lib/find_sqlite.cmake

@@ -14,11 +14,46 @@ The library fully supports the SQLite duck typing concept, but it also offers a
 libsl3 stared as a C++98 project long time ago.
 Later, when C++11 was new, it became <i>a modern C++11 interface to sqlite</i>.
 Today, libsl3 it's still around. A C++ interface for SQLite.
-
-Today, active development is on pause, but the library is still maintained and updated of required.
+Active development happens rarely but the library is still maintained and updated if required.
 
 \section Installation
 
+libsl3 can be build and consumed without any external dependencies. But you might want to use sqlite3 installations from your system.
+
+\subsection consume Consuming sl3 in a CMake project
+
+An easy way is consuming sl3 via CMake's 'FetchContent'
+
+\code
+cmake_minimum_required(VERSION 3.29)
+
+project(consume_sl3)
+
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_STANDARD 20)
+
+include(FetchContent)
+FetchContent_Declare(
+  sl3
+  GIT_REPOSITORY https://github.com/a4z/libsl3.git
+  GIT_TAG        main
+  OVERRIDE_FIND_PACKAGE
+)
+SET(BUILD_TESTING OFF)
+SET(sl3_USE_INTERNAL_SQLITE3 ON)
+SET(sl3_USE_COMMON_COMPILER_WARNINGS OFF)
+
+find_package(sl3 CONFIG REQUIRED)
+
+add_executable(consume_sl3 main.cpp)
+target_link_libraries(consume_sl3 PRIVATE sl3)
+\endcode
+
+If you want to use the system sqlite3 installation, you can omit the line
+`SET(sl3_USE_INTERNAL_SQLITE3 ON)`
+
+\section build_from_source Building sl3 from source
+
 Get you copy of the source code from the <a href="https://github.com/a4z/libsl3">libsl3 GitHub repository</a>.
 
 The project has the following dependencies:
@@ -28,11 +63,19 @@ The project has the following dependencies:
 \li Optional: <a href="https://www.doxygen.nl">doxygen</a> for buliding the documentation
 \li Optional: <a href="https://github.com/doctest/doctest">doctest</a> for unit testing
 
+\subsection deal_dependencies Dependency management
+
+There are 3 options to deal with dependencies.
+
+\li Ignore them, and turn them off. (No testing and internal sqlite3)
+\li Use vcpkg, a package manager for C++ libraries
+\li Use CMake's FetchContent to fetch the dependencies
+
 If doxygen is not found it will not be possible to build the documentation.
 
-doctest is fetched on demand, except if \c BUILD_TESTING is set to OFF.
+See below for how to use either vcpkg or FetchContent.
 
-\subsection build Building the library
+\subsection build Building the library (developer mode)
 
 The library can be build with CMake. No surprises here.
 
@@ -63,20 +106,20 @@ ctest --preset msvc22
 In case you do not have vcpkg installed, the most simple way to get started is
 
 \code
-cmake --preset ninja -DPROJECT_ADDONS=add-on/fetch-dependencies -DUSE_INTERNAL_SQLITE3=ON
+cmake --preset ninja -DPROJECT_ADDONS=add-on/fetch-dependencies -Dsl3_USE_INTERNAL_SQLITE3=ON
 \endcode
 
-If you have sqlite3 installed on your system, you can use it by omitting -DUSE_INTERNAL_SQLITE3=ON
+If you have sqlite3 installed on your system, you can use it by omitting -Dsl3_USE_INTERNAL_SQLITE3=ON
 
 
 <b>CMake options to control the build process:</b>
 
-\li \c USE_INTERNAL_SQLITE3:<BR>
+\li \c sl3_USE_INTERNAL_SQLITE3:<BR>
 If set to ON, the internal sqlite3 source code will be used.<BR>
 If set to OFF, the system sqlite3 will be used.<BR>
 Default is ON.
 
-\li \c BUILD_TESTING:<BR>
+\li \c sl3_BUILD_TESTING:<BR>
 If set to ON, test targets will be added .<BR>
 Default is ON.
 
@@ -98,13 +141,13 @@ Programs consuming libsl3 do not need to link against sqlite3.
 \li Slightly longer build time for building libsl3
 (not for programs consuming libsl3)
 
-\section Testing
+\subsection Testing
 
 All the tests can be found in the tests subdirectory. <BR>
 Existing tests try to cover as much as possible, see the <a href=coverage/index.html>coverage report</a> for details.
 
 
-\section overview Overview
+\section overview Usage Overview
 
 A database is represented via sl3::Database. <BR>
 A database can execute SQL strings to read or write data. <BR>

CMake/lib/install.cmake renamed to cmake/lib/install.cmake

@@ -129,7 +129,7 @@ target_link_libraries( sl3 PUBLIC ${CMAKE_THREAD_LIBS_INIT} )
 #message(STATUS "**DEFINES ARE: "${mysqlt3_DEFINES} )
 #message(STATUS "**LIBRARIES ARE: "${sl3_sqlite3LIBS} )
 
-# else (USE_INTERNAL_SQLITE3)
+# else (sl3_USE_INTERNAL_SQLITE3)
 #         INCLUDE(FindPkgConfig)
 
 #         # TODO define a minimum version 3.3.8