inkcpp_rb 0.1.0

data/ext/inkcpp_rb/inkcpp/inkcpp_cl/CMakeLists.txt

@@ -0,0 +1,49 @@
+# Create executable
+add_executable(inkcpp_cl inkcpp_cl.cpp test.h test.cpp)
+
+# Include compiler and runtime libraries
+target_link_libraries(inkcpp_cl PUBLIC inkcpp inkcpp_compiler inkcpp_shared)
+
+# For https://en.cppreference.com/w/cpp/filesystem#Notes
+if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+  if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "9.1")
+    target_link_libraries(inkcpp_cl PRIVATE stdc++fs)
+  endif()
+elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+  if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "9.0")
+    target_link_libraries(inkcpp_cl PRIVATE stdc++fs)
+  endif()
+endif()
+
+# Install
+install(TARGETS inkcpp_cl DESTINATION . COMPONENT cl EXCLUDE_FROM_ALL)
+string(TOUPPER "${INKCPP_INKLECATE}" inkcpp_inklecate_upper)
+unset(inklecate_dir)
+if((inkcpp_inklecate_upper STREQUAL "ALL") OR (inkcpp_inklecate_upper STREQUAL "OS"))
+  if(UNIX AND NOT APPLE)
+    FetchContent_GetProperties(inklecate_linux)
+    if(inklecate_linux_POPULATED)
+      set(inklecate_dir "${inklecate_linux_SOURCE_DIR}")
+    else()
+      message(WARNING "Inklecate for this OS was not downloaded successfully, and will therfore not be packat with cl")
+    endif(inklecate_linux_POPULATED)
+  elseif(APPLE)
+    if(inklecate_mac_POPULATED)
+      set(inklecate_dir "${inklecate_mac_SOURCE_DIR}")
+    else()
+      message(WARNING "Inklecate for this OS was not downloaded successfully, and will therfore not be packat with cl")
+    endif(inklecate_mac_POPULATED)
+  elseif(MSYS OR MINGW OR WIN32 OR CYGWIN)
+    if(inklecate_windows_POPULATED)
+      set(inklecate_dir "${inklecate_windows_SOURCE_DIR}")
+    else()
+      message(WARNING "Inklecate for this OS was not downloaded successfully, and will therfore not be packat with cl")
+    endif(inklecate_windows_POPULATED)
+  else()
+      message(WARNING "Failed to determine OS for bundling inklecate with command line application!")
+  endif()
+  if(inklecate_dir)
+    file(GLOB inklecate_files "${inklecate_dir}/*")
+    install(FILES ${inklecate_files} DESTINATION . COMPONENT cl EXCLUDE_FROM_ALL)
+  endif(inklecate_dir)
+endif((inkcpp_inklecate_upper STREQUAL "ALL") OR (inkcpp_inklecate_upper STREQUAL "OS"))

data/ext/inkcpp_rb/inkcpp/inkcpp_cl/inkcpp_cl.cpp

@@ -0,0 +1,215 @@
+// inkcpp_cl.cpp : This file contains the 'main' function. Program execution begins and ends there.
+//
+
+#include <iostream>
+#include <fstream>
+#include <regex>
+
+#include <story.h>
+#include <runner.h>
+#include <compiler.h>
+#include <choice.h>
+#include <globals.h>
+#include <snapshot.h>
+
+#include "test.h"
+
+void usage()
+{
+	using namespace std;
+	cout << "Usage: inkcpp_cl <options> <json file>\n"
+	     << "\t-o <filename>:\tOutput file name\n"
+	     << "\t-p [<snapshot_file>]:\tPlay mode\n\toptional snapshot file to load\n\tto create a "
+	        "snapshot file enter '-1' as choice\n"
+	     << "\t--ommit-choice-tags:\tdo not print tags after choices, primarly used to be compatible "
+	        "with inkclecat output"
+	     << "\t--inklecate <path-to-inklecate>:\toverwrites INKLECATE enviroment variable\n"
+	     << endl;
+}
+
+int main(int argc, const char** argv)
+{
+	// Usage
+	if (argc == 1) {
+		usage();
+		return 1;
+	}
+
+	// Parse options
+	std::string outputFilename;
+	bool        playMode = false, testMode = false, testDirectory = false, ommit_choice_tags = false;
+	std::string snapshotFile;
+	const char* inklecateOverwrite = nullptr;
+	for (int i = 1; i < argc - 1; i++) {
+		std::string option = argv[i];
+		if (option == "-o") {
+			outputFilename = argv[i + 1];
+			i += 1;
+		} else if (option == "-p") {
+			playMode = true;
+			if (i + 1 < argc - 1 && argv[i + 1][0] != '-') {
+				++i;
+				snapshotFile = argv[i];
+			}
+		} else if (option == "--ommit-choice-tags") {
+			ommit_choice_tags = true;
+		} else if (option == "-t") {
+			testMode = true;
+		} else if (option == "-td") {
+			testMode      = true;
+			testDirectory = true;
+		} else if (option == "--inklecate") {
+			if (i + 1 < argc - 1 && argv[i + 1][0] != '-') {
+				++i;
+				inklecateOverwrite = argv[i];
+			}
+		} else {
+			std::cerr << "Unrecognized option: '" << option << "'\n";
+		}
+	}
+
+	// Get input filename
+	std::string inputFilename = argv[argc - 1];
+
+	// Test mode
+	// if (testMode) {
+	// 	bool result;
+	// 	if (testDirectory) {
+	// 		result = test_directory(inputFilename);
+	// 	} else {
+	// 		result = test(inputFilename);
+	// 	}
+
+	// 	return result ? 0 : -1;
+	// }
+
+	// If output filename not specified, use input filename as guideline
+	if (outputFilename.empty()) {
+		outputFilename = std::regex_replace(inputFilename, std::regex("\\.[^\\.]+$"), ".bin");
+	}
+
+	// If input filename is an .ink file
+	int  val                   = inputFilename.find(".ink");
+	bool json_file_is_tmp_file = false;
+	if (val == inputFilename.length() - 4) {
+		// Create temporary filename
+		std::string jsonFile = std::regex_replace(inputFilename, std::regex("\\.[^\\.]+$"), ".tmp");
+
+		// Then we need to do a compilation with inklecate
+		try {
+			inklecate(inputFilename, jsonFile, inklecateOverwrite);
+		} catch (const std::exception& e) {
+			std::cerr << "Inklecate Error: " << e.what() << std::endl;
+			return 1;
+		}
+
+		// New input is the json file
+		json_file_is_tmp_file = true;
+		inputFilename         = jsonFile;
+	}
+
+	// Open file and compile
+	try {
+		ink::compiler::compilation_results results;
+		std::ofstream                      fout(outputFilename, std::ios::binary | std::ios::out);
+		ink::compiler::run(inputFilename.c_str(), fout, &results);
+		fout.close();
+		if (json_file_is_tmp_file) {
+			remove(inputFilename.c_str());
+		}
+
+		// Report errors
+		for (auto& warn : results.warnings) {
+			std::cerr << "WARNING: " << warn << '\n';
+		}
+		for (auto& err : results.errors) {
+			std::cerr << "ERROR: " << err << '\n';
+		}
+
+		if (results.errors.size() > 0 && playMode) {
+			std::cerr << "Cancelling play mode. Errors detected in compilation" << std::endl;
+			return -1;
+		}
+	} catch (std::exception& e) {
+		if (json_file_is_tmp_file) {
+			remove(inputFilename.c_str());
+		}
+		std::cerr << "Unhandled InkBin compiler exception: " << e.what() << std::endl;
+		return 1;
+	}
+
+	if (! playMode) {
+		return 0;
+	}
+
+	// Run the story
+	try {
+		using namespace ink::runtime;
+
+		// Load story
+		std::unique_ptr<story> myInk{story::from_file(outputFilename.c_str())};
+
+		// Start runner
+		runner thread;
+		if (snapshotFile.size()) {
+			auto snap_ptr = snapshot::from_file(snapshotFile.c_str());
+			thread        = myInk->new_runner_from_snapshot(*snap_ptr);
+			delete snap_ptr;
+		} else {
+			thread = myInk->new_runner();
+		}
+
+		while (true) {
+			while (thread->can_continue()) {
+				std::cout << thread->getline();
+				if (thread->has_tags()) {
+					std::cout << "# tags: ";
+					for (int i = 0; i < thread->num_tags(); ++i) {
+						if (i != 0) {
+							std::cout << ", ";
+						}
+						std::cout << thread->get_tag(i);
+					}
+					std::cout << std::endl;
+				}
+			}
+			if (thread->has_choices()) {
+				// Extra end line
+				std::cout << std::endl;
+
+				int index = 1;
+				for (const ink::runtime::choice& c : *thread) {
+					std::cout << index++ << ": " << c.text();
+					if (! ommit_choice_tags && c.has_tags()) {
+						std::cout << "\n\t";
+						for (size_t i = 0; i < c.num_tags(); ++i) {
+							std::cout << "# " << c.get_tag(i) << " ";
+						}
+					}
+					std::cout << std::endl;
+				}
+
+				int c = 0;
+				std::cout << "?> ";
+				std::cin >> c;
+				if (c == -1) {
+					snapshot* snap = thread->create_snapshot();
+					snap->write_to_file(
+					    std::regex_replace(inputFilename, std::regex("\\.[^\\.]+$"), ".snap").c_str()
+					);
+					delete snap;
+					break;
+				}
+				thread->choose(c - 1);
+				continue;
+			}
+
+			// out of content
+			break;
+		}
+	} catch (const std::exception& e) {
+		std::cerr << "Unhandled ink runtime exception: " << e.what() << std::endl;
+		return 1;
+	}
+	return 0;
+}

data/ext/inkcpp_rb/inkcpp/inkcpp_cl/test.cpp

@@ -0,0 +1,209 @@
+#include "test.h"
+
+#include <fstream>
+#include <sstream>
+#include <regex>
+#include <filesystem>
+#include <cstdlib>
+
+#include <globals.h>
+#include <runner.h>
+#include <story.h>
+#include <compiler.h>
+#include <choice.h>
+
+void inklecate(
+    const std::string& inkFilename, const std::string& jsonFilename, const char* inklecateOverwrite
+)
+{
+	// Get environment specific inklecate invocation command
+
+	const char* inklecateCmd = nullptr;
+	if (inklecateCmd == nullptr) {
+		if (inklecateOverwrite) {
+			inklecateCmd = inklecateOverwrite;
+		}
+	}
+	if (inklecateCmd == nullptr) {
+		std::getenv("INKLECATE");
+	}
+	if (inklecateCmd == nullptr)
+		inklecateCmd = "inklecate";
+
+	// Create command
+	std::stringstream cmd;
+	cmd << inklecateCmd << " -o \"" << jsonFilename << "\" \"" << inkFilename << "\"";
+
+	// Run
+	int result = std::system(cmd.str().c_str());
+	if (result != 0) {
+		std::stringstream msg; msg << "Inklecate failed with exit code " << result;
+		throw std::runtime_error(msg.str());
+	}
+}
+
+void load_file(const std::string& filename, std::string& result)
+{
+	// Open file
+	std::ifstream file(filename.c_str());
+
+	// Get size
+	file.seekg(0, std::ios::end);
+	result.reserve(file.tellg());
+	file.seekg(0, std::ios::beg);
+
+	// Load into string
+	result.assign(std::istreambuf_iterator<char>(file), std::istreambuf_iterator<char>());
+
+	// Close
+	file.close();
+}
+
+bool test(const std::string& inkFilename)
+{
+	using namespace ink::runtime;
+
+	std::cout << std::filesystem::path(inkFilename).filename().string() << std::endl;
+
+	// Compile into a temporary json file
+	inklecate(inkFilename, "test.tmp", nullptr);
+
+	// Compile into binary
+	ink::compiler::compilation_results results;
+	ink::compiler::run("test.tmp", "test.bin", &results);
+
+	std::vector<std::string> expectations;
+	std::vector<int> choices;
+	std::vector<std::string> choiceStrings;
+
+	{
+		// Load entire ink file into memory
+		std::string inkFile;
+		load_file(inkFilename, inkFile);
+
+		// Check for ignore
+		if (inkFile.find("//IGNORE") == 0)
+		{
+			std::cout << "IGNORED" << std::endl;
+			return true;
+		}
+
+		// Check for compile errors post ignore
+		if (results.errors.size() > 0)
+		{
+			for (auto& error : results.errors)
+			{
+				std::cerr << "ERROR: " << error << std::endl;
+			}
+			return false;
+		}
+
+		// Load expectations
+		auto reg = std::regex("\\/\\*\\*[ \t]*(\\d+(:.+)?)?[ \t]*\n((.|\n)*?)\\*\\*\\/");
+		auto iter = std::sregex_iterator(inkFile.begin(), inkFile.end(), reg);
+		auto end = std::sregex_iterator();
+
+		// Go through them
+		for (; iter != end; ++iter)
+		{
+			if ((*iter)[1].matched)
+			{
+				expectations.push_back((*iter)[3].str());
+				choices.push_back(atoi((*iter)[1].str().c_str()));
+				
+				if ((*iter)[2].matched)
+					choiceStrings.push_back((*iter)[2].str().substr(1));
+				else
+					choiceStrings.push_back("");
+			}
+			else
+			{
+				expectations.push_back((*iter)[3].str());
+			}
+		}
+
+		std::reverse(expectations.begin(), expectations.end());
+		std::reverse(choices.begin(), choices.end());
+	}
+
+	// Load story
+	auto file = story::from_file("test.bin");
+	auto runner = file->new_runner();
+
+	while (true)
+	{
+		// Run continuously
+		std::string output = runner->getall();
+
+		// Check against expectatins
+		if (expectations.size() == 0)
+		{
+			std::cout << "FAIL: Extra content detected in ink file:\n"
+				<< output;
+			return false;
+		}
+
+		// Check against expectations
+		std::string expect = *expectations.rbegin();
+		expectations.pop_back();
+		bool success = output == expect;
+		if (!success)
+		{
+			std::cout << "FAIL: Mismatch\n";
+			std::cout << "== Expected ==\n"
+				<< expect;
+			std::cout << "\n== Actual ==\n"
+				<< output;
+			return false;
+		}
+
+		if (runner->has_choices())
+		{
+			if (choices.size() == 0)
+			{
+				std::cout << "FAIL: Encountered choice without choice index" << std::endl;
+				return false;
+			}
+
+			// Pick choice
+			int choice = *choices.rbegin();
+			choices.pop_back();
+
+			// Make sure text matches
+			std::string choiceStr = *choiceStrings.rbegin();
+			choiceStrings.pop_back();
+			if (choiceStr != "" && runner->get_choice(choice)->text() != choiceStr)
+			{
+				std::cout << "FAIL: CHOICE MISMATCH\n";
+
+				std::cout << "== Expected ==\n"
+					<< choiceStr << "\n"
+					<< "== Actual ==\n"
+					<< runner->get_choice(choice)->text() << std::endl;
+				return false;
+			}
+
+			runner->choose(choice);
+		}
+		else
+			break;
+	}
+
+	std::cout << "SUCCESS!" << std::endl;
+	return true;
+}
+
+bool test_directory(const std::string& directory)
+{
+	for (auto p : std::filesystem::directory_iterator(directory))
+	{
+		if (p.path().extension() == ".ink")
+		{
+			bool success = test(p.path().string());
+			if (!success)
+				return false;
+		}
+	}
+
+	return true;
+}

data/ext/inkcpp_rb/inkcpp/inkcpp_cl/test.h

@@ -0,0 +1,8 @@
+#include <string>
+
+void inklecate(
+    const std::string& inkFilename, const std::string& jsonFilename, const char* inkclecateOverwrite
+);
+// TODO: reevaluate in ink file test mechanism
+// bool test(const std::string& inkFilename);
+// bool test_directory(const std::string& directory);

data/ext/inkcpp_rb/inkcpp/inkcpp_compiler/CMakeLists.txt

@@ -0,0 +1,37 @@
+list(APPEND SOURCES
+    compiler.cpp binary_stream.h binary_stream.cpp json.hpp
+    json_compiler.h json_compiler.cpp 
+    emitter.h emitter.cpp
+    reporter.h reporter.cpp
+    binary_emitter.h binary_emitter.cpp
+	list_data.h list_data.cpp
+    command.cpp
+    )
+add_definitions(-DINK_EXPOSE_JSON)
+add_library(inkcpp_compiler_o OBJECT ${SOURCES})
+add_library(inkcpp_compiler $<TARGET_OBJECTS:inkcpp_compiler_o>)
+
+target_include_directories(inkcpp_compiler_o PUBLIC
+	$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+	$<INSTALL_INTERFACE:include>
+)
+target_include_directories(inkcpp_compiler PUBLIC
+	$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+	$<INSTALL_INTERFACE:include>
+)
+FILE(GLOB PUBLIC_HEADERS "include/*")
+set_target_properties(inkcpp_compiler PROPERTIES PUBLIC_HEADER "${PUBLIC_HEADERS}")
+
+target_link_libraries(inkcpp_compiler PRIVATE inkcpp_shared)
+target_link_libraries(inkcpp_compiler_o PRIVATE inkcpp_shared)
+
+# Make sure this project and all dependencies use the C++17 standard
+target_compile_features(inkcpp_compiler PUBLIC cxx_std_17)
+target_compile_features(inkcpp_compiler PUBLIC cxx_std_17)
+
+# Unreal installation
+list(REMOVE_ITEM SOURCES "json.hpp")
+install(FILES "json.hpp" DESTINATION "inkcpp/Source/ThirdParty/Private/"
+	COMPONENT unreal EXCLUDE_FROM_ALL)
+install(DIRECTORY "include/" DESTINATION "inkcpp/Source/inkcpp_editor/Private/ink/" COMPONENT unreal EXCLUDE_FROM_ALL)
+install(FILES ${SOURCES} DESTINATION "inkcpp/Source/inkcpp_editor/Private/ink/" COMPONENT unreal EXCLUDE_FROM_ALL)