Update CMake files.

libvalkey/CMakeLists.txt

@@ -2,7 +2,7 @@ CMAKE_MINIMUM_REQUIRED(VERSION 3.0.0)
 
 MACRO(getVersionBit name)
   SET(VERSION_REGEX "^#define ${name} (.+)$")
-  FILE(STRINGS "${CMAKE_CURRENT_SOURCE_DIR}/hiredis.h"
+  FILE(STRINGS "${CMAKE_CURRENT_SOURCE_DIR}/valkey.h"
     VERSION_BIT REGEX ${VERSION_REGEX})
   STRING(REGEX REPLACE ${VERSION_REGEX} "\\1" ${name} "${VERSION_BIT}")
 ENDMACRO(getVersionBit)
@@ -14,139 +14,139 @@ getVersionBit(LIBVALKEY_SONAME)
 SET(VERSION "${LIBVALKEY_MAJOR}.${LIBVALKEY_MINOR}.${LIBVALKEY_PATCH}")
 MESSAGE("Detected version: ${VERSION}")
 
-PROJECT(hiredis LANGUAGES "C" VERSION "${VERSION}")
+PROJECT(valkey LANGUAGES "C" VERSION "${VERSION}")
 INCLUDE(GNUInstallDirs)
 
 OPTION(BUILD_SHARED_LIBS "Build shared libraries" ON)
-OPTION(ENABLE_SSL "Build hiredis_ssl for SSL support" OFF)
+OPTION(ENABLE_SSL "Build valkey_ssl for SSL support" OFF)
 OPTION(DISABLE_TESTS "If tests should be compiled or not" OFF)
 OPTION(ENABLE_SSL_TESTS "Should we test SSL connections" OFF)
-OPTION(ENABLE_EXAMPLES "Enable building hiredis examples" OFF)
+OPTION(ENABLE_EXAMPLES "Enable building valkey examples" OFF)
 OPTION(ENABLE_ASYNC_TESTS "Should we run all asynchronous API tests" OFF)
 # Historically, the NuGet file was always install; default
 # to ON for those who rely on that historical behaviour.
 OPTION(ENABLE_NUGET "Install NuGET packaging details" ON)
 
-# Hiredis requires C99
+# valkey requires C99
 SET(CMAKE_C_STANDARD 99)
 SET(CMAKE_DEBUG_POSTFIX d)
 
-SET(hiredis_sources
+SET(valkey_sources
     alloc.c
     async.c
-    hiredis.c
+    valkey.c
     net.c
     read.c
     sds.c
     sockcompat.c)
 
-SET(hiredis_sources ${hiredis_sources})
+SET(valkey_sources ${valkey_sources})
 
 IF(WIN32)
     ADD_DEFINITIONS(-D_CRT_SECURE_NO_WARNINGS -DWIN32_LEAN_AND_MEAN)
 ENDIF()
 
-ADD_LIBRARY(hiredis ${hiredis_sources})
-ADD_LIBRARY(hiredis::hiredis ALIAS hiredis)
-set(hiredis_export_name hiredis CACHE STRING "Name of the exported target")
-set_target_properties(hiredis PROPERTIES EXPORT_NAME ${hiredis_export_name})
+ADD_LIBRARY(valkey ${valkey_sources})
+ADD_LIBRARY(valkey::valkey ALIAS valkey)
+set(valkey_export_name valkey CACHE STRING "Name of the exported target")
+set_target_properties(valkey PROPERTIES EXPORT_NAME ${valkey_export_name})
 
-SET_TARGET_PROPERTIES(hiredis
+SET_TARGET_PROPERTIES(valkey
     PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS TRUE
     VERSION "${LIBVALKEY_SONAME}")
 IF(MSVC)
-    SET_TARGET_PROPERTIES(hiredis
+    SET_TARGET_PROPERTIES(valkey
         PROPERTIES COMPILE_FLAGS /Z7)
 ENDIF()
 IF(WIN32)
-    TARGET_LINK_LIBRARIES(hiredis PUBLIC ws2_32 crypt32)
+    TARGET_LINK_LIBRARIES(valkey PUBLIC ws2_32 crypt32)
 ELSEIF(CMAKE_SYSTEM_NAME MATCHES "FreeBSD")
-    TARGET_LINK_LIBRARIES(hiredis PUBLIC m)
+    TARGET_LINK_LIBRARIES(valkey PUBLIC m)
 ELSEIF(CMAKE_SYSTEM_NAME MATCHES "SunOS")
-    TARGET_LINK_LIBRARIES(hiredis PUBLIC socket)
+    TARGET_LINK_LIBRARIES(valkey PUBLIC socket)
 ENDIF()
 
-TARGET_INCLUDE_DIRECTORIES(hiredis PUBLIC $<INSTALL_INTERFACE:include> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>)
+TARGET_INCLUDE_DIRECTORIES(valkey PUBLIC $<INSTALL_INTERFACE:include> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>)
 
-CONFIGURE_FILE(hiredis.pc.in hiredis.pc @ONLY)
+CONFIGURE_FILE(valkey.pc.in valkey.pc @ONLY)
 
-set(CPACK_PACKAGE_VENDOR "Redis")
+set(CPACK_PACKAGE_VENDOR "Valkey")
 set(CPACK_PACKAGE_DESCRIPTION "\
 Libvalkey is a minimalistic C client library for the Valkey, KeyDB, and Redis databases
 
 It is minimalistic because it just adds minimal support for the protocol, \
 but at the same time it uses a high level printf-alike API in order to make \
 it much higher level than otherwise suggested by its minimal code base and the \
-lack of explicit bindings for every Redis command.
+lack of explicit bindings for every server command.
 
 Apart from supporting sending commands and receiving replies, it comes with a \
 reply parser that is decoupled from the I/O layer. It is a stream parser designed \
 for easy reusability, which can for instance be used in higher level language bindings \
 for efficient reply parsing.
 
-Hiredis only supports the binary-safe Redis protocol, so you can use it with any Redis \
-version >= 1.2.0.
+valkey only supports the binary-safe RESP protocol, so you can use it with any Redis \
+compatible server >= 1.2.0.
 
 The library comes with multiple APIs. There is the synchronous API, the asynchronous API \
 and the reply parsing API.")
-set(CPACK_PACKAGE_HOMEPAGE_URL "https://github.com/redis/hiredis")
+set(CPACK_PACKAGE_HOMEPAGE_URL "https://github.com/valkey-io/libvalkey")
 set(CPACK_PACKAGE_CONTACT "michael dot grunder at gmail dot com")
 set(CPACK_DEBIAN_PACKAGE_SHLIBDEPS ON)
 set(CPACK_RPM_PACKAGE_AUTOREQPROV ON)
 
 include(CPack)
 
-INSTALL(TARGETS hiredis
-    EXPORT hiredis-targets
+INSTALL(TARGETS valkey
+    EXPORT valkey-targets
     RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
     LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
     ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
 
 if (MSVC AND BUILD_SHARED_LIBS)
-    INSTALL(FILES $<TARGET_PDB_FILE:hiredis>
+    INSTALL(FILES $<TARGET_PDB_FILE:valkey>
         DESTINATION ${CMAKE_INSTALL_BINDIR}
         CONFIGURATIONS Debug RelWithDebInfo)
 endif()
 
 if (ENABLE_NUGET)
     # For NuGet packages
-    INSTALL(FILES hiredis.targets
+    INSTALL(FILES valkey.targets
         DESTINATION build/native)
 endif()
 
-INSTALL(FILES hiredis.h read.h sds.h async.h alloc.h sockcompat.h
-    DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/hiredis)
+INSTALL(FILES valkey.h read.h sds.h async.h alloc.h sockcompat.h
+    DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/valkey)
 
 INSTALL(DIRECTORY adapters
-    DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/hiredis)
+    DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/valkey)
 
-INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/hiredis.pc
+INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/valkey.pc
     DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
 
-export(EXPORT hiredis-targets
-    FILE "${CMAKE_CURRENT_BINARY_DIR}/hiredis-targets.cmake"
-    NAMESPACE hiredis::)
+export(EXPORT valkey-targets
+    FILE "${CMAKE_CURRENT_BINARY_DIR}/valkey-targets.cmake"
+    NAMESPACE valkey::)
 
 if(WIN32)
-    SET(CMAKE_CONF_INSTALL_DIR share/hiredis)
+    SET(CMAKE_CONF_INSTALL_DIR share/valkey)
 else()
-    SET(CMAKE_CONF_INSTALL_DIR ${CMAKE_INSTALL_LIBDIR}/cmake/hiredis)
+    SET(CMAKE_CONF_INSTALL_DIR ${CMAKE_INSTALL_LIBDIR}/cmake/valkey)
 endif()
 SET(INCLUDE_INSTALL_DIR include)
 include(CMakePackageConfigHelpers)
-write_basic_package_version_file("${CMAKE_CURRENT_BINARY_DIR}/hiredis-config-version.cmake"
+write_basic_package_version_file("${CMAKE_CURRENT_BINARY_DIR}/valkey-config-version.cmake"
                                  COMPATIBILITY SameMajorVersion)
-configure_package_config_file(hiredis-config.cmake.in ${CMAKE_CURRENT_BINARY_DIR}/hiredis-config.cmake
+configure_package_config_file(valkey-config.cmake.in ${CMAKE_CURRENT_BINARY_DIR}/valkey-config.cmake
                               INSTALL_DESTINATION ${CMAKE_CONF_INSTALL_DIR}
                               PATH_VARS INCLUDE_INSTALL_DIR)
 
-INSTALL(EXPORT hiredis-targets
-        FILE hiredis-targets.cmake
-        NAMESPACE hiredis::
+INSTALL(EXPORT valkey-targets
+        FILE valkey-targets.cmake
+        NAMESPACE valkey::
         DESTINATION ${CMAKE_CONF_INSTALL_DIR})
 
-INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/hiredis-config.cmake
-              ${CMAKE_CURRENT_BINARY_DIR}/hiredis-config-version.cmake
+INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/valkey-config.cmake
+              ${CMAKE_CURRENT_BINARY_DIR}/valkey-config-version.cmake
         DESTINATION ${CMAKE_CONF_INSTALL_DIR})
 
 
@@ -157,82 +157,82 @@ IF(ENABLE_SSL)
         ENDIF()
     ENDIF()
     FIND_PACKAGE(OpenSSL REQUIRED)
-    SET(hiredis_ssl_sources
+    SET(valkey_ssl_sources
         ssl.c)
-    ADD_LIBRARY(hiredis_ssl ${hiredis_ssl_sources})
-    ADD_LIBRARY(hiredis::hiredis_ssl ALIAS hiredis_ssl)
+    ADD_LIBRARY(valkey_ssl ${valkey_ssl_sources})
+    ADD_LIBRARY(valkey::valkey_ssl ALIAS valkey_ssl)
 
     IF (APPLE AND BUILD_SHARED_LIBS)
-        SET_PROPERTY(TARGET hiredis_ssl PROPERTY LINK_FLAGS "-Wl,-undefined -Wl,dynamic_lookup")
+        SET_PROPERTY(TARGET valkey_ssl PROPERTY LINK_FLAGS "-Wl,-undefined -Wl,dynamic_lookup")
     ENDIF()
 
-    SET_TARGET_PROPERTIES(hiredis_ssl
+    SET_TARGET_PROPERTIES(valkey_ssl
         PROPERTIES
         WINDOWS_EXPORT_ALL_SYMBOLS TRUE
         VERSION "${LIBVALKEY_SONAME}")
     IF(MSVC)
-        SET_TARGET_PROPERTIES(hiredis_ssl
+        SET_TARGET_PROPERTIES(valkey_ssl
             PROPERTIES COMPILE_FLAGS /Z7)
     ENDIF()
-    TARGET_LINK_LIBRARIES(hiredis_ssl PRIVATE OpenSSL::SSL)
+    TARGET_LINK_LIBRARIES(valkey_ssl PRIVATE OpenSSL::SSL)
     IF(WIN32)
-        TARGET_LINK_LIBRARIES(hiredis_ssl PRIVATE hiredis)
+        TARGET_LINK_LIBRARIES(valkey_ssl PRIVATE valkey)
     ENDIF()
-    CONFIGURE_FILE(hiredis_ssl.pc.in hiredis_ssl.pc @ONLY)
+    CONFIGURE_FILE(valkey_ssl.pc.in valkey_ssl.pc @ONLY)
 
-    INSTALL(TARGETS hiredis_ssl
-        EXPORT hiredis_ssl-targets
+    INSTALL(TARGETS valkey_ssl
+        EXPORT valkey_ssl-targets
         RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
         LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
         ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
 
     if (MSVC AND BUILD_SHARED_LIBS)
-        INSTALL(FILES $<TARGET_PDB_FILE:hiredis_ssl>
+        INSTALL(FILES $<TARGET_PDB_FILE:valkey_ssl>
             DESTINATION ${CMAKE_INSTALL_BINDIR}
             CONFIGURATIONS Debug RelWithDebInfo)
     endif()
 
-    INSTALL(FILES hiredis_ssl.h
-        DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/hiredis)
+    INSTALL(FILES valkey_ssl.h
+        DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/valkey)
 
-    INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/hiredis_ssl.pc
+    INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/valkey_ssl.pc
         DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
 
-    export(EXPORT hiredis_ssl-targets
-           FILE "${CMAKE_CURRENT_BINARY_DIR}/hiredis_ssl-targets.cmake"
-           NAMESPACE hiredis::)
+    export(EXPORT valkey_ssl-targets
+           FILE "${CMAKE_CURRENT_BINARY_DIR}/valkey_ssl-targets.cmake"
+           NAMESPACE valkey::)
 
     if(WIN32)
-        SET(CMAKE_CONF_INSTALL_DIR share/hiredis_ssl)
+        SET(CMAKE_CONF_INSTALL_DIR share/valkey_ssl)
     else()
-        SET(CMAKE_CONF_INSTALL_DIR ${CMAKE_INSTALL_LIBDIR}/cmake/hiredis_ssl)
+        SET(CMAKE_CONF_INSTALL_DIR ${CMAKE_INSTALL_LIBDIR}/cmake/valkey_ssl)
     endif()
-    configure_package_config_file(hiredis_ssl-config.cmake.in ${CMAKE_CURRENT_BINARY_DIR}/hiredis_ssl-config.cmake
+    configure_package_config_file(valkey_ssl-config.cmake.in ${CMAKE_CURRENT_BINARY_DIR}/valkey_ssl-config.cmake
                                   INSTALL_DESTINATION ${CMAKE_CONF_INSTALL_DIR}
                                   PATH_VARS INCLUDE_INSTALL_DIR)
 
-    INSTALL(EXPORT hiredis_ssl-targets
-        FILE hiredis_ssl-targets.cmake
-        NAMESPACE hiredis::
+    INSTALL(EXPORT valkey_ssl-targets
+        FILE valkey_ssl-targets.cmake
+        NAMESPACE valkey::
         DESTINATION ${CMAKE_CONF_INSTALL_DIR})
 
-    INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/hiredis_ssl-config.cmake
+    INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/valkey_ssl-config.cmake
         DESTINATION ${CMAKE_CONF_INSTALL_DIR})
 ENDIF()
 
 IF(NOT DISABLE_TESTS)
     ENABLE_TESTING()
-    ADD_EXECUTABLE(hiredis-test test.c)
-    TARGET_LINK_LIBRARIES(hiredis-test hiredis)
+    ADD_EXECUTABLE(libvalkey-test test.c)
+    TARGET_LINK_LIBRARIES(libvalkey-test valkey)
     IF(ENABLE_SSL_TESTS)
 	ADD_DEFINITIONS(-DVALKEY_TEST_SSL=1)
-        TARGET_LINK_LIBRARIES(hiredis-test hiredis_ssl)
+        TARGET_LINK_LIBRARIES(libvalkey-test valkey_ssl)
     ENDIF()
     IF(ENABLE_ASYNC_TESTS)
 	ADD_DEFINITIONS(-DVALKEY_TEST_ASYNC=1)
-        TARGET_LINK_LIBRARIES(hiredis-test event)
+        TARGET_LINK_LIBRARIES(libvalkey-test event)
     ENDIF()
-    ADD_TEST(NAME hiredis-test
+    ADD_TEST(NAME libvalkey-test
         COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/test.sh)
 ENDIF()
 

libvalkey/examples/CMakeLists.txt

@@ -6,7 +6,7 @@ if (GLIB2_FOUND)
     INCLUDE_DIRECTORIES(${GLIB2_INCLUDE_DIRS})
     LINK_DIRECTORIES(${GLIB2_LIBRARY_DIRS})
     ADD_EXECUTABLE(example-glib example-glib.c)
-    TARGET_LINK_LIBRARIES(example-glib hiredis ${GLIB2_LIBRARIES})
+    TARGET_LINK_LIBRARIES(example-glib valkey ${GLIB2_LIBRARIES})
 ENDIF(GLIB2_FOUND)
 
 FIND_PATH(LIBEV ev.h
@@ -16,46 +16,46 @@ FIND_PATH(LIBEV ev.h
 if (LIBEV)
     # Just compile and link with libev
     ADD_EXECUTABLE(example-libev example-libev.c)
-    TARGET_LINK_LIBRARIES(example-libev hiredis ev)
+    TARGET_LINK_LIBRARIES(example-libev valkey ev)
 ENDIF()
 
 FIND_PATH(LIBEVENT event.h)
 if (LIBEVENT)
     ADD_EXECUTABLE(example-libevent example-libevent.c)
-    TARGET_LINK_LIBRARIES(example-libevent hiredis event)
+    TARGET_LINK_LIBRARIES(example-libevent valkey event)
 ENDIF()
 
 FIND_PATH(LIBHV hv/hv.h)
 IF (LIBHV)
     ADD_EXECUTABLE(example-libhv example-libhv.c)
-    TARGET_LINK_LIBRARIES(example-libhv hiredis hv)
+    TARGET_LINK_LIBRARIES(example-libhv valkey hv)
 ENDIF()
 
 FIND_PATH(LIBUV uv.h)
 IF (LIBUV)
     ADD_EXECUTABLE(example-libuv example-libuv.c)
-    TARGET_LINK_LIBRARIES(example-libuv hiredis uv)
+    TARGET_LINK_LIBRARIES(example-libuv valkey uv)
 ENDIF()
 
 FIND_PATH(LIBSDEVENT systemd/sd-event.h)
 IF (LIBSDEVENT)
     ADD_EXECUTABLE(example-libsdevent example-libsdevent.c)
-    TARGET_LINK_LIBRARIES(example-libsdevent hiredis systemd)
+    TARGET_LINK_LIBRARIES(example-libsdevent valkey systemd)
 ENDIF()
 
 IF (APPLE)
     FIND_LIBRARY(CF CoreFoundation)
     ADD_EXECUTABLE(example-macosx example-macosx.c)
-    TARGET_LINK_LIBRARIES(example-macosx hiredis ${CF})
+    TARGET_LINK_LIBRARIES(example-macosx valkey ${CF})
 ENDIF()
 
 IF (ENABLE_SSL)
     ADD_EXECUTABLE(example-ssl example-ssl.c)
-    TARGET_LINK_LIBRARIES(example-ssl hiredis hiredis_ssl)
+    TARGET_LINK_LIBRARIES(example-ssl valkey valkey_ssl)
 ENDIF()
 
 ADD_EXECUTABLE(example example.c)
-TARGET_LINK_LIBRARIES(example hiredis)
+TARGET_LINK_LIBRARIES(example valkey)
 
 ADD_EXECUTABLE(example-push example-push.c)
-TARGET_LINK_LIBRARIES(example-push hiredis)
+TARGET_LINK_LIBRARIES(example-push valkey)

libvalkey/valkey-config.cmake.in

@@ -1,13 +1,13 @@
 @PACKAGE_INIT@
 
-set_and_check(hiredis_INCLUDEDIR "@PACKAGE_INCLUDE_INSTALL_DIR@")
+set_and_check(valkey_INCLUDEDIR "@PACKAGE_INCLUDE_INSTALL_DIR@")
 
-IF (NOT TARGET hiredis::@hiredis_export_name@)
-	INCLUDE(${CMAKE_CURRENT_LIST_DIR}/hiredis-targets.cmake)
+IF (NOT TARGET valkey::@valkey_export_name@)
+	INCLUDE(${CMAKE_CURRENT_LIST_DIR}/valkey-targets.cmake)
 ENDIF()
 
-SET(hiredis_LIBRARIES hiredis::@hiredis_export_name@)
-SET(hiredis_INCLUDE_DIRS ${hiredis_INCLUDEDIR})
+SET(valkey_LIBRARIES valkey::@valkey_export_name@)
+SET(valkey_INCLUDE_DIRS ${valkey_INCLUDEDIR})
 
-check_required_components(hiredis)
+check_required_components(valkey)