inkcpp_rb 0.1.0

data/ext/inkcpp_rb/inkcpp/inkcpp_compiler/reporter.h

@@ -0,0 +1,55 @@
+/* Copyright (c) 2024 Julian Benda
+ *
+ * This file is part of inkCPP which is released under MIT license.
+ * See file LICENSE.txt or go to
+ * https://github.com/JBenda/inkcpp for full license details.
+ */
+#pragma once
+
+#include "compilation_results.h"
+#include <sstream>
+
+namespace ink::compiler::internal
+{
+	class error_strbuf : public std::stringbuf
+	{
+	public:
+		// start a new error message to be outputted to a given list
+		void start(error_list* list);
+
+		// If set, the next sync will throw an exception
+		void throw_on_sync(bool);
+	protected:
+		virtual int sync() override;
+
+	private:
+		error_list* _list = nullptr;
+		bool _throw = false;
+	};
+
+	class reporter
+	{
+	protected:
+		reporter();
+		virtual ~reporter() { }
+
+		// sets the results pointer for this reporter
+		void set_results(compilation_results*);
+
+		// clears the results pointer
+		void clear_results();
+
+		// report warning
+		std::ostream& warn();
+
+		// report error
+		std::ostream& err();
+		
+		// report critical error
+		std::ostream& crit();
+	private:
+		compilation_results* _results;
+		error_strbuf _buffer;
+		std::ostream _stream;
+	};
+  } // namespace ink::compiler::internal

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

@@ -0,0 +1,19 @@
+add_subdirectory(pybind11)
+pybind11_add_module(inkcpp_py src/module.cpp)
+target_compile_definitions(inkcpp_py PRIVATE VERSION_INFO=${VERSION})
+
+target_link_libraries(inkcpp_py 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_py PRIVATE stdc++fs)
+  endif()
+elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+  if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "9.0")
+    target_link_libraries(inkcpp_py PRIVATE stdc++fs)
+  endif()
+endif()
+
+install(TARGETS inkcpp_py DESTINATION . COMPONENT py EXCLUDE_FROM_ALL)

data/ext/inkcpp_rb/inkcpp/inkcpp_py/example.py

@@ -0,0 +1,78 @@
+#!/bin/python
+
+import inkcpp_py
+import sys
+import os
+
+story_ink = 'unreal_example.ink'
+story_json = 'unreal_example.ink.json'
+story_bin = 'unreal_example.bin'
+
+
+# convert .ink / .json file to .bin file
+if not os.path.exists(story_bin):
+    if not os.path.exists(story_json):
+        os.system('inklecate {}'.format(story_ink))
+    inkcpp_py.compile_json(story_json, story_bin)
+
+# load story and maybe snapshot
+story = inkcpp_py.Story.from_file(story_bin)
+if len(sys.argv) > 1:
+    snap = inkcpp_py.Snapshot.from_file(sys.argv[1])
+    globals = story.new_globals_from_snapshot(snap)
+    runner = story.new_runner_from_snapshot(snap, globals)
+else:
+    globals = story.new_globals()
+    runner = story.new_runner(globals)
+
+# access global variables
+print("Date: ", globals.date)
+globals.date = inkcpp_py.Value("17.12.2023")
+bg = globals.background.as_list();
+print(bg)
+bg.add('b')
+print(bg)
+bg.remove('a')
+print(bg)
+globals.background = inkcpp_py.Value(bg)
+
+# observer examples
+def ob_delta(x, y):
+    print("from:",y,"to:",x)
+
+globals.observe("brightness", ob_delta)
+
+
+# external function with no input, but return value
+def greeting(a):
+    return inkcpp_py.Value("Tach")
+runner.bind("GetGreeting", greeting)
+
+# external function with no return value
+def brightness(args):
+    print("Set Brightness: ", args[0])
+runner.bind_void("SetBrightness", brightness)
+
+# simple story stepper
+while True:
+    while runner.can_continue():
+        print(runner.getline())
+    print("# tags: ", end="")
+    print(', '.join(runner.tags()))
+    if runner.has_choices():
+        print()
+        index = 1
+        for c in runner:
+            print(str(index) + ": " + c.text())
+            print("\t"+', '.join(c.tags()))
+            index += 1
+        index = int(input('Select choice to continue: '))
+        if index == -1:
+            snap = runner.create_snapshot();
+            snap.write_to_file("story.snap");
+            break
+        else:
+            runner.choose(index - 1)
+    else:
+        break
+print("Finish")

data/ext/inkcpp_rb/inkcpp/inkcpp_py/src/module.cpp

@@ -0,0 +1,317 @@
+#include "compilation_results.h"
+#include "story_ptr.h"
+#include "types.h"
+#include <pybind11/attr.h>
+#include <pybind11/cast.h>
+#include <pybind11/detail/common.h>
+#include <pybind11/pybind11.h>
+#include <pybind11/pytypes.h>
+#include <pybind11/stl.h>
+#include <pybind11/functional.h>
+
+namespace py = pybind11;
+
+#include <story.h>
+#include <runner.h>
+#include <compiler.h>
+#include <choice.h>
+#include <globals.h>
+#include <snapshot.h>
+
+#include <sstream>
+#include <functional>
+
+using runner      = ink::runtime::runner_interface;
+using runner_ptr  = ink::runtime::runner;
+using globals     = ink::runtime::globals_interface;
+using globals_ptr = ink::runtime::globals;
+using story       = ink::runtime::story;
+using choice      = ink::runtime::choice;
+using value       = ink::runtime::value;
+using list        = ink::runtime::list_interface;
+using snapshot    = ink::runtime::snapshot;
+
+PYBIND11_DECLARE_HOLDER_TYPE(T, ink::runtime::story_ptr<T>);
+
+struct StringValueWrap : public value {
+	StringValueWrap(const std::string& s)
+	    : value()
+	    , str{s}
+	{
+		static_cast<value&>(*this) = value(str.c_str());
+	}
+
+	~StringValueWrap() {}
+
+	std::string str;
+};
+
+std::string list_to_str(const list& list)
+{
+	std::stringstream out;
+	out << "[";
+	bool first = true;
+	for (const auto& flag : list) {
+		if (first) {
+			first = false;
+		} else {
+			out << ", ";
+		}
+		out << flag;
+	}
+	out << "]";
+	return out.str();
+}
+
+PYBIND11_MODULE(inkcpp_py, m)
+{
+	m.doc()
+	    = "Python bindings for InkCPP https://github.com/JBenda/inkcpp"; // optional module docstring
+
+	py::class_<story>(m, "Story")
+	    .def("from_file", &story::from_file, "Creates a new story from a .bin file")
+	    .def("new_globals", &story::new_globals, "creates new globals store for the current story")
+	    .def("new_runner", [](story& self) { return self.new_runner(); })
+	    .def("new_runner", &story::new_runner, "creates a new runner for the current story")
+	    .def("new_globals_from_snapshot", &story::new_globals_from_snapshot)
+	    .def("new_runner_from_snapshot", &story::new_runner_from_snapshot)
+	    .def(
+	        "new_runner_from_snapshot", [](story& self, const snapshot& snap, globals_ptr store
+	                                    ) { return self.new_runner_from_snapshot(snap, store); }
+	    )
+	    .def("new_runner_from_snapshot", [](story& self, const snapshot& snap) {
+		    return self.new_runner_from_snapshot(snap);
+	    });
+
+	py::class_<globals, globals_ptr>(m, "Globals")
+	    .def(
+	        "create_snapshot", &globals::create_snapshot,
+	        "Creates a snapshot from the current state for later usage"
+	    )
+	    .def(
+	        "observe",
+	        [](globals& self, const char* name,
+	           std::function<void(const value&, ink::optional<const value>)> f) {
+		        self.observe(name, f);
+	        },
+	        "Get a call with the new and old value (this could be None) each time the variable "
+	        "changes"
+	    )
+	    .def(
+	        "__getattr__",
+	        [](const globals& self, const std::string& key) {
+		        auto res = self.get<value>(key.c_str());
+		        if (! res.has_value()) {
+			        throw py::key_error(std::string("No global variable with name '") + key + "' found");
+		        }
+		        return res.value();
+	        },
+	        "Access global varible if exists, if not throws an key_error"
+	    )
+	    .def("__setattr__", [](globals& self, const std::string& key, const value& val) {
+		    if (! self.set<value>(key.c_str(), val)) {
+			    throw py::key_error(
+			        std::string("No global variable with name '") + key
+			        + "' found or you are trying to override a non string variable with a string"
+			    );
+		    }
+	    });
+
+	py::class_<list, std::unique_ptr<list, py::nodelete>> py_list(
+	    m, "List",
+	    "Allows reading and editing inkcpp lists. !Only valid until next choose ore getline a runner "
+	    "referncing the corresponding global"
+	);
+	py_list.def("add", &list::add, "Add flag to list")
+	    .def("remove", &list::remove, "Remove flag from list")
+	    .def("contains", &list::contains, "Check if list contains the given flag")
+	    .def(
+	        "flags_from",
+	        [](const list& self, const char* list_name) {
+		        return py::make_iterator(self.begin(list_name), self.end());
+	        },
+	        "Rerutrns all flags contained in list from a list", py::keep_alive<0, 1>()
+	    )
+	    .def(
+	        "__iter__", [](const list& self) { return py::make_iterator(self.begin(), self.end()); },
+	        py::keep_alive<0, 1>()
+	    )
+	    .def("__str__", &list_to_str);
+	py::class_<list::iterator::Flag>(
+	    py_list, "Flag", "A list flag containing the name of the flag and the corresponding list"
+	)
+	    .def_readonly("name", &list::iterator::Flag::flag_name, "The flag")
+	    .def_readonly(
+	        "list_name", &list::iterator::Flag::list_name, "Name of the corresponding list"
+	    );
+
+	py::class_<value> py_value(m, "Value", "A Value of a Ink Variable");
+	py_value.def_readonly("type", &value::type, "Type contained in value");
+	py_value.def(py::init<>());
+	py_value.def(py::init<bool>());
+	py_value.def("__init__", [](value& self, uint32_t v, value::Type type) {
+		if (type != value::Type::Uint32) {
+			throw py::key_error("only use this signture if you want to explicit pass a uint");
+		}
+		self = value(v);
+	});
+	py_value.def(py::init<int32_t>());
+	py_value.def(py::init<float>());
+	py_value.def(py::init<list*>());
+	py_value.def(py::init([](const std::string& str) { return new StringValueWrap(str); }));
+	py_value.def(
+	    "as_list",
+	    [](const value& self) {
+		    if (self.type != value::Type::List) {
+			    throw py::attribute_error("Try to access list of non list value");
+		    }
+		    return self.get<value::Type::List>();
+	    },
+	    py::return_value_policy::reference
+	);
+	py_value.def("__str__", [](const value& self) {
+		switch (self.type) {
+			case value::Type::Bool: return std::string(self.get<value::Type::Bool>() ? "true" : "false");
+			case value::Type::Uint32: return std::to_string(self.get<value::Type::Uint32>());
+			case value::Type::Int32: return std::to_string(self.get<value::Type::Int32>());
+			case value::Type::String: return std::string(self.get<value::Type::String>());
+			case value::Type::Float: return std::to_string(self.get<value::Type::Float>());
+			case value::Type::List: {
+				return list_to_str(*self.get<value::Type::List>());
+			}
+		}
+		throw py::attribute_error("value is in an invalid state");
+	});
+
+	py::enum_<value::Type>(py_value, "Type")
+	    .value("Bool", value::Type::Bool)
+	    .value("Uint32", value::Type::Uint32)
+	    .value("Int32", value::Type::Int32)
+	    .value("String", value::Type::String)
+	    .value("Float", value::Type::Float)
+	    .value("List", value::Type::List)
+	    .export_values();
+
+	py::class_<runner, runner_ptr>(m, "Runner")
+	    .def(
+	        "create_snapshot", &runner::create_snapshot,
+	        "Creates a snapshot from the current state for later usage"
+	    )
+	    .def("can_continue", &runner::can_continue, "check if there is content left in story")
+	    .def(
+	        "getline", static_cast<std::string (runner::*)()>(&runner::getline),
+	        "Get content of one output line"
+	    )
+	    .def(
+	        "getall", static_cast<std::string (runner::*)()>(&runner::getall),
+	        "execute getline and append until can_continue is false"
+	    )
+	    .def("has_tags", &runner::has_tags, "Where there tags since last getline?")
+	    .def("num_tags", &runner::num_tags, "Number of tags currently stored")
+	    .def(
+	        "get_tag", &runner::get_tag, "Get Tag currently stored at position i",
+	        py::return_value_policy::reference_internal
+	    )
+	    .def(
+	        "tags",
+	        [](const runner& self) {
+		        std::vector<const char*> tags(self.num_tags());
+		        for (size_t i = 0; i < self.num_tags(); ++i) {
+			        tags[i] = self.get_tag(i);
+		        }
+		        return tags;
+	        },
+	        "Get all current assigned tags"
+	    )
+	    .def(
+	        "has_choices", &runner::has_choices,
+	        "Check if there is at least one open choice at the moment."
+	    )
+	    .def(
+	        "get_choice", &runner::get_choice, "Get current choice at index",
+	        py::return_value_policy::reference_internal
+	    )
+	    .def("num_choices", &runner::num_choices, "Number of current open choices")
+	    .def(
+	        "__iter__",
+	        [](const runner& self) { return py::make_iterator(self.begin(), self.end()); },
+	        py::keep_alive<0, 1>()
+	    )
+	    .def("choose", &runner::choose, "Select a choice to continue")
+	    .def(
+	        "bind_void",
+	        [](runner& self, const char* function_name, std::function<void(std::vector<value>)> f,
+	           bool lookaheadSafe) {
+		        self.bind(
+		            function_name,
+		            [f](size_t len, const value* vals) {
+			            std::vector args(vals, vals + len);
+			            f(args);
+		            },
+		            lookaheadSafe
+		        );
+	        },
+	        py::arg("function_name"), py::arg("function"), py::arg_v("lookaheadSafe", false),
+	        "Bind function with void result"
+	    )
+	    .def(
+	        "bind",
+	        [](runner& self, const char* function_name, std::function<value(std::vector<value>)> f,
+	           bool lookaheadSafe) {
+		        self.bind(function_name, [f](size_t len, const value* vals) {
+			        std::vector args(vals, vals + len);
+			        return f(args);
+		        });
+	        },
+	        py::arg("function_name"), py::arg("function"), py::arg_v("lookaheadSafe", false),
+	        "Bind a function with return value"
+	    )
+	    .def(
+	        "move_to",
+	        [](runner& self, const char* path) -> bool {
+		        return self.move_to(ink::hash_string(path));
+	        },
+	        "Moves execution pointer to start of container desrcipet by the path"
+	    );
+	py::class_<choice>(m, "Choice")
+	    .def("text", &choice::text, "Get choice printable content")
+	    .def("has_tags", &choice::has_tags, "if choices is tagged?")
+	    .def("num_tags", &choice::num_tags, "Number of tags assigned to choice")
+	    .def(
+	        "get_tag", &choice::get_tag, "Get tag at index",
+	        py::return_value_policy::reference_internal
+	    )
+	    .def(
+	        "tags",
+	        [](const choice& self) {
+		        std::vector<const char*> tags(self.num_tags());
+		        for (size_t i = 0; i < self.num_tags(); ++i) {
+			        tags[i] = self.get_tag(i);
+		        }
+		        return tags;
+	        },
+	        "Get all current assinged tags"
+	    );
+	py::class_<snapshot>(
+	    m, "Snapshot", "Globals and all assoziatet runner stored for later restoration"
+	)
+	    .def("num_runners", &snapshot::num_runners, "Number of different runners stored in snapshot")
+	    .def("write_to_file", &snapshot::write_to_file, "Store snapshot in file")
+	    .def("from_file", &snapshot::from_file, "Load snapshot from file");
+	m.def(
+	    "compile_json",
+	    [](const char* input_file_name, const char* output_filen_ame) {
+		    ink::compiler::compilation_results results;
+		    ink::compiler::run(input_file_name, output_filen_ame, &results);
+		    if (! results.errors.empty()) {
+			    std::string str;
+			    for (auto& error : results.errors) {
+				    str += error;
+				    str += '\n';
+			    }
+			    throw py::value_error(str);
+		    }
+	    },
+	    "Converts a story.json file to a story.bin file used by inkcpp"
+	);
+}

data/ext/inkcpp_rb/inkcpp/inkcpp_py/tests/conftest.py

@@ -0,0 +1,53 @@
+import pytest
+import os
+import sys
+import inkcpp_py as ink
+
+@pytest.fixture(scope='session', autouse=True)
+def inklecate_cmd():
+    res = os.getenv("INKLECATE")
+    if res is None or res == "":
+        return "inklecate"
+    return res
+
+
+def extract_paths(tmpdir):
+    def res(ink_source):
+        name = os.path.splitext(os.path.basename(ink_source))[0]
+        return (
+        name,
+            list(map(lambda x: tmpdir + ("/" + name + x), [".bin", ".tmp"])) + ["./inkcpp_test/ink/" + ink_source]
+        )
+    return res
+
+@pytest.fixture(scope='session', autouse=True)
+def story_path(tmpdir_factory):
+    tmpdir = tmpdir_factory.getbasetemp()
+    # tmpdir = os.fsencode('/tmp/pytest')
+    return {name: files 
+        for (name, files) in map(extract_paths(tmpdir), 
+            filter(
+                lambda file: os.path.splitext(file)[1] == ".ink", 
+                os.listdir("./inkcpp_test/ink/")))}
+            
+@pytest.fixture(scope='session', autouse=True)
+def assets(story_path, inklecate_cmd):
+    res = {}
+    for (name, files) in story_path.items():
+        if not os.path.exists(files[0]):
+            if not os.path.exists(files[1]):
+                os.system('{} -o {} {}'.format(inklecate_cmd, files[1], files[2]))
+            ink.compile_json(str(files[1]), str(files[0]))
+        res[name] = ink.Story.from_file(str(files[0]))
+    return res
+
+@pytest.fixture(scope='session', autouse=True)
+def generate():
+    def g(asset):
+        store = asset.new_globals()
+        return [
+            asset,
+            store,
+            asset.new_runner(store),
+        ]
+    return g

data/ext/inkcpp_rb/inkcpp/inkcpp_py/tests/test_ExternalFunctions.py

@@ -0,0 +1,35 @@
+import inkcpp_py as ink
+import pytest
+import os
+
+class Cnt:
+    def __init__(self):
+        self.cnt = 0
+    def __call__(self, _):
+        self.cnt += 1
+class TestExternalFunctions:
+    def test_lookaheadSafe(self, assets, generate):
+        cnt = Cnt()
+        [story, globals, runner] = generate(assets['LookaheadSafe'])
+        runner.bind_void("foo", cnt, True)
+        out = runner.getline()
+        assert out == "Call1 glued to Call 2\n"
+        assert cnt.cnt == 3
+        out = runner.getline()
+        assert out == "Call 3 is seperated\n"
+        assert cnt.cnt == 4
+
+    def test_lookahadeUnsafe(self, assets, generate):
+        cnt = Cnt()
+        [story, globals, runner] = generate(assets['LookaheadSafe'])
+        runner.bind_void("foo", cnt)
+        out = runner.getline()
+        assert out == "Call1\n"
+        assert cnt.cnt == 1
+        out = runner.getline()
+        assert out == "glued to Call 2\n"
+        assert cnt.cnt == 2
+        out = runner.getline()
+        assert out == "Call 3 is seperated\n"
+        assert cnt.cnt == 3
+    

data/ext/inkcpp_rb/inkcpp/inkcpp_py/tests/test_Globals.py

@@ -0,0 +1,40 @@
+import inkcpp_py as ink
+import pytest
+
+
+class TestGlobals:
+    def test_reading_globals(self, assets, generate):
+        [story, globals, runner] = generate(assets['GlobalStory'])
+
+        assert runner.getline() == "My name is Jean Passepartout, but my friend's call me Jackie. I'm 23 years old.\n"
+        assert runner.getline() == "Foo:23\n"
+
+        val = globals.age
+        assert val.type == ink.Value.Int32 and str(val) == '23'
+        val = globals.friendly_name_of_player
+        assert val.type == ink.Value.String and str(val) == 'Jackie'
+
+    def test_writing_globals(self, assets, generate):
+        [story, globals, runner] = generate(assets['GlobalStory'])
+        globals.age = ink.Value(30)
+        globals.friendly_name_of_player = ink.Value("Freddy")
+
+        
+        assert runner.getline() == "My name is Jean Passepartout, but my friend's call me Freddy. I'm 30 years old.\n"
+        assert runner.getline() == "Foo:30\n"
+
+        val = globals.age
+        assert val.type == ink.Value.Int32 and str(val) == '30'
+        val = globals.friendly_name_of_player
+        assert val.type == ink.Value.String and str(val) == 'Freddy'
+        
+
+    def test_invalid_operations(self, assets, generate):
+        [story, globals, runner] = generate(assets['GlobalStory'])
+
+        with pytest.raises(KeyError):
+            val = globals.foo
+        with pytest.raises(KeyError):
+            globals.foo = ink.Value(0)
+        with pytest.raises(KeyError):
+            globals.age = ink.Value('foo')

data/ext/inkcpp_rb/inkcpp/inkcpp_py/tests/test_Lists.py

@@ -0,0 +1,43 @@
+import inkcpp_py as ink
+
+class TestLists:
+    def test_lists(self, assets, generate):
+        [story, globals, runner] = generate(assets['ListStory'])
+
+        val = globals.list
+        l = val.as_list()
+        hits = [False, False, False]
+        for flag in l:
+            if flag.name == 'bird' and flag.list_name == 'animals':
+                hits[0] = True
+            elif flag.name == 'red' and flag.list_name == 'colors':
+                hits[1] = True
+            elif flag.name == 'yellow' and flag.list_name == 'colors':
+                hits[2] = True
+            else:
+                assert False
+        assert hits[0] and hits[1] and hits[2]
+
+        hits = [False, False]
+        for flag in l.flags_from('colors'):
+            if flag.name == 'red' and flag.list_name == 'colors':
+                hits[0] = True
+            elif flag.name == 'yellow' and flag.list_name == 'colors':
+                hits[1] = True
+            else:
+                assert False
+        assert hits[0] and hits[1]
+
+        assert l.contains('yellow')
+        assert not l.contains('white')
+
+        l.add('white')
+        l.remove('yellow')
+
+        assert not l.contains('yellow')
+        assert l.contains('white')
+
+        globals.list = ink.Value(l)
+
+        assert runner.getline() == 'cat, snake\n'
+        assert runner.get_choice(0).text() == 'list: bird, white, red'

data/ext/inkcpp_rb/inkcpp/inkcpp_py/tests/test_Observer.py

@@ -0,0 +1,27 @@
+import inkcpp_py as ink
+import pytest
+
+class Observer:
+    def __init__(self):
+        self.cnt = 0
+    def __call__(self, new, old):
+        self.cnt += 1
+        if self.cnt == 1:
+            assert new.type == ink.Value.Int32 and str(new) == '1'
+            assert old is None
+        else:
+            assert new.type == ink.Value.Int32 and str(new) == '5'
+            assert old.type == ink.Value.Int32 and str(old) == '1'
+            
+
+class TestObserver:
+    def test_observer(self, assets, generate):
+        [story, store, runner] = generate(assets['ObserverStory'])
+
+        obs = Observer()
+        store.observe('var1', obs)
+
+        assert runner.getline() == "hello line 1 1 hello line 2 5 test line 3 5\n"
+        assert obs.cnt == 2
+
+