Merge the Codegen project into Blaze (#739)

Mostly out of convenience. So we don't have to be switching between
projects and upgrading them all the time. Lots of time wasted due to
that.

Signed-off-by: Juan Cruz Viotti <jv@jviotti.com>

Author: jviotti

.github/workflows/ci.yml

@@ -97,6 +97,7 @@ jobs:
         env:
           HOMEBREW_NO_ANALYTICS: 1
           HOMEBREW_NO_AUTO_UPDATE: 1
+      - run: npm ci
       - run: cmake --version
       - name: Configure Blaze (static)
         if: matrix.platform.type == 'static'

.github/workflows/website-build.yml

@@ -22,6 +22,7 @@ jobs:
           -DBLAZE_TEST:BOOL=OFF
           -DBLAZE_CONFIGURATION:BOOL=OFF
           -DBLAZE_ALTERSCHEMA:BOOL=OFF
+          -DBLAZE_CODEGEN:BOOL=OFF
           -DBLAZE_TESTS:BOOL=OFF
           -DBLAZE_DOCS:BOOL=ON
       - run: cmake --build ./build --config Release --target doxygen

.github/workflows/website-deploy.yml

@@ -33,6 +33,7 @@ jobs:
           -DBLAZE_TEST:BOOL=OFF
           -DBLAZE_CONFIGURATION:BOOL=OFF
           -DBLAZE_ALTERSCHEMA:BOOL=OFF
+          -DBLAZE_CODEGEN:BOOL=OFF
           -DBLAZE_TESTS:BOOL=OFF
           -DBLAZE_DOCS:BOOL=ON
       - run: cmake --build ./build --config Release --target doxygen

CMakeLists.txt

@@ -11,6 +11,7 @@ option(BLAZE_OUTPUT "Build the Blaze output formats library" ON)
 option(BLAZE_TEST "Build the Blaze test runner library" ON)
 option(BLAZE_CONFIGURATION "Build the Blaze configuration file library" ON)
 option(BLAZE_ALTERSCHEMA "Build the Blaze alterschema rule library" ON)
+option(BLAZE_CODEGEN "Build the Blaze codegen library" ON)
 option(BLAZE_TESTS "Build the Blaze tests" OFF)
 option(BLAZE_BENCHMARK "Build the Blaze benchmarks" OFF)
 option(BLAZE_CONTRIB "Build the Blaze contrib programs" OFF)
@@ -67,6 +68,10 @@ if(BLAZE_ALTERSCHEMA)
   add_subdirectory(src/alterschema)
 endif()
 
+if(BLAZE_CODEGEN)
+  add_subdirectory(src/codegen)
+endif()
+
 if(BLAZE_CONTRIB)
   add_subdirectory(contrib)
 endif()
@@ -134,6 +139,10 @@ if(BLAZE_TESTS)
     add_subdirectory(test/alterschema)
   endif()
 
+  if(BLAZE_CODEGEN)
+    add_subdirectory(test/codegen)
+  endif()
+
   if(PROJECT_IS_TOP_LEVEL)
     # Otherwise we need the child project to link
     # against the sanitizers too.

Makefile

@@ -1,14 +1,18 @@
 # Programs
 CMAKE = cmake
 CTEST = ctest
+NPM = npm
 
 # Options
 PRESET = Debug
 SHARED = OFF
 
 all: configure compile test
 
-configure: .always
+node_modules: package.json package-lock.json
+	$(NPM) ci
+
+configure: node_modules .always
 	$(CMAKE) -S . -B ./build \
 		-DCMAKE_BUILD_TYPE:STRING=$(PRESET) \
 		-DCMAKE_COMPILE_WARNING_AS_ERROR:BOOL=ON \

cmake/FindCore.cmake

@@ -5,7 +5,6 @@ if(NOT Core_FOUND)
     set(SOURCEMETA_CORE_INSTALL OFF CACHE BOOL "disable installation")
   endif()
 
-  set(SOURCEMETA_CORE_EXTENSION_OPTIONS OFF CACHE BOOL "disable")
   set(SOURCEMETA_CORE_EXTENSION_BUILD OFF CACHE BOOL "disable")
 
   set(SOURCEMETA_CORE_CONTRIB_GOOGLETEST ${BLAZE_TESTS} CACHE BOOL "GoogleTest")

config.cmake.in

@@ -10,6 +10,7 @@ if(NOT BLAZE_COMPONENTS)
   list(APPEND BLAZE_COMPONENTS test)
   list(APPEND BLAZE_COMPONENTS configuration)
   list(APPEND BLAZE_COMPONENTS alterschema)
+  list(APPEND BLAZE_COMPONENTS codegen)
 endif()
 
 include(CMakeFindDependencyMacro)
@@ -35,6 +36,12 @@ foreach(component ${BLAZE_COMPONENTS})
     include("${CMAKE_CURRENT_LIST_DIR}/sourcemeta_blaze_compiler.cmake")
     include("${CMAKE_CURRENT_LIST_DIR}/sourcemeta_blaze_output.cmake")
     include("${CMAKE_CURRENT_LIST_DIR}/sourcemeta_blaze_alterschema.cmake")
+  elseif(component STREQUAL "codegen")
+    include("${CMAKE_CURRENT_LIST_DIR}/sourcemeta_blaze_evaluator.cmake")
+    include("${CMAKE_CURRENT_LIST_DIR}/sourcemeta_blaze_compiler.cmake")
+    include("${CMAKE_CURRENT_LIST_DIR}/sourcemeta_blaze_output.cmake")
+    include("${CMAKE_CURRENT_LIST_DIR}/sourcemeta_blaze_alterschema.cmake")
+    include("${CMAKE_CURRENT_LIST_DIR}/sourcemeta_blaze_codegen.cmake")
   else()
     message(FATAL_ERROR "Unknown Blaze component: ${component}")
   endif()

contrib/CMakeLists.txt

@@ -60,6 +60,15 @@ if(BLAZE_COMPILER AND BLAZE_EVALUATOR)
   endif()
 endif()
 
+if(BLAZE_CODEGEN)
+  sourcemeta_executable(NAMESPACE sourcemeta PROJECT blaze NAME contrib_typescript
+    FOLDER "Blaze/Contrib" SOURCES typescript.cc)
+  target_link_libraries(sourcemeta_blaze_contrib_typescript
+    PRIVATE sourcemeta::blaze::codegen)
+  target_link_libraries(sourcemeta_blaze_contrib_typescript
+    PRIVATE sourcemeta::core::options)
+endif()
+
 if(BLAZE_ALTERSCHEMA)
   sourcemeta_executable(NAMESPACE sourcemeta PROJECT blaze
     NAME contrib_canonicalize

contrib/typescript.cc

@@ -0,0 +1,75 @@
+#include <sourcemeta/blaze/codegen.h>
+#include <sourcemeta/blaze/codegen_error.h>
+
+#include <sourcemeta/core/json.h>
+#include <sourcemeta/core/jsonschema.h>
+#include <sourcemeta/core/options.h>
+
+#include <cstdlib>    // EXIT_SUCCESS, EXIT_FAILURE
+#include <filesystem> // std::filesystem::path
+#include <iostream>   // std::cout, std::cerr
+#include <sstream>    // std::ostringstream
+#include <string>     // std::string
+
+auto main(int argc, char *argv[]) -> int {
+  sourcemeta::core::Options options;
+  options.option("default-prefix", {"p"});
+  options.parse(argc, argv);
+
+  const auto &positional_arguments{options.positional()};
+  if (positional_arguments.empty()) {
+    std::cerr << "error: missing schema path\n";
+    return EXIT_FAILURE;
+  }
+
+  const std::filesystem::path schema_path{positional_arguments.front()};
+
+  try {
+    const auto schema{sourcemeta::core::read_json(schema_path)};
+
+    const auto result{
+        sourcemeta::blaze::compile(schema, sourcemeta::core::schema_walker,
+                                   sourcemeta::core::schema_resolver,
+                                   sourcemeta::blaze::default_compiler)};
+
+    const std::string prefix{
+        options.contains("default-prefix")
+            ? std::string{options.at("default-prefix").front()}
+            : "Schema"};
+
+    sourcemeta::blaze::generate<sourcemeta::blaze::TypeScript>(std::cout,
+                                                               result, prefix);
+  } catch (const sourcemeta::blaze::CodegenUnsupportedKeywordError &error) {
+    std::ostringstream pointer;
+    sourcemeta::core::stringify(error.pointer(), pointer);
+    std::cerr << "error: " << error.what() << "\n";
+    std::cerr << "  keyword: " << error.keyword() << "\n";
+    std::cerr << "  location: " << pointer.str() << "\n";
+    std::cerr << "  schema: ";
+    sourcemeta::core::prettify(error.json(), std::cerr);
+    std::cerr << "\n";
+    return EXIT_FAILURE;
+  } catch (
+      const sourcemeta::blaze::CodegenUnsupportedKeywordValueError &error) {
+    std::ostringstream pointer;
+    sourcemeta::core::stringify(error.pointer(), pointer);
+    std::cerr << "error: " << error.what() << "\n";
+    std::cerr << "  keyword: " << error.keyword() << "\n";
+    std::cerr << "  location: " << pointer.str() << "\n";
+    std::cerr << "  schema: ";
+    sourcemeta::core::prettify(error.json(), std::cerr);
+    std::cerr << "\n";
+    return EXIT_FAILURE;
+  } catch (const sourcemeta::blaze::CodegenUnexpectedSchemaError &error) {
+    std::ostringstream pointer;
+    sourcemeta::core::stringify(error.pointer(), pointer);
+    std::cerr << "error: " << error.what() << "\n";
+    std::cerr << "  location: " << pointer.str() << "\n";
+    std::cerr << "  schema: ";
+    sourcemeta::core::prettify(error.json(), std::cerr);
+    std::cerr << "\n";
+    return EXIT_FAILURE;
+  }
+
+  return EXIT_SUCCESS;
+}