inkcpp_rb 0.1.0

data/ext/inkcpp_rb/inkcpp_rb.cpp

@@ -0,0 +1,321 @@
+#include <iostream>
+#include <rice/rice.hpp>
+#include <rice/stl.hpp>
+
+#include <ink/story.h>
+#include <ink/choice.h>
+#include <ink/snapshot.h>
+#include <ink/globals.h>
+#include <ink/runner.h>
+#include <ink/types.h>
+#include <ink/compiler.h>
+#include <ink/list.h>
+#include <ink/compilation_results.h>
+
+using namespace Rice;
+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 story_ptr   = ink::runtime::story_ptr<globals>;
+using choice      = ink::runtime::choice;
+using value       = ink::runtime::value;
+using list        = ink::runtime::list_interface;
+using snapshot    = ink::runtime::snapshot;
+//TODO: probably should be a shared pointer / smart pointer
+using bound_func  = std::function<value(std::vector<value>&)>;
+
+namespace Rice::detail
+{
+  template<>
+  struct Type<bound_func*>
+  {
+    static bool verify()
+    {
+      return true;
+    }
+  };
+
+  template<>
+  class From_Ruby<bound_func*>
+  {
+    public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
+    bool is_convertible(VALUE value)
+    {
+      return rb_obj_is_proc(value) == RUBY_Qtrue;
+    }
+
+    bound_func* convert(VALUE lambda)
+    {
+        VALUE check = detail::protect(rb_obj_is_proc, lambda);
+        if(check != RUBY_Qtrue){
+            throw std::runtime_error("Object is not convertible");
+        }
+        bound_func * result = new bound_func([lambda](std::vector<value> & args) {
+            detail::To_Ruby<value> to_convertor;
+            VALUE ary = rb_ary_new2(args.size());
+            for(value v: args) {
+                rb_ary_push(ary, to_convertor.convert(v));
+            }
+            VALUE v = rb_proc_call(lambda, ary);
+            detail::From_Ruby<value> from_convertor;
+            switch(TYPE(v)) {
+                case T_FIXNUM:
+                    return value((int32_t)NUM2INT(v));
+                case T_FLOAT:
+                    return value((float)RFLOAT_VALUE(v));
+                case T_STRING:
+                    return value(StringValueCStr(v));
+                case T_OBJECT:
+                    if(from_convertor.is_convertible(v)) {
+                        value result = from_convertor.convert(v);
+                        return result;
+                    } else {
+                        const char * str = rb_string_value_cstr(&v);
+                        if(str !=  NULL) {
+                            return value(str);
+                        } else {
+                            return value(RB_TEST(v));
+                        }
+                    }
+            }
+            throw std::runtime_error("Result must be a valid ink value type");
+        });
+        return result;
+    }
+
+    private:
+    Arg* arg_ = nullptr;
+  };
+}
+
+
+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();
+}
+
+extern "C"
+void Init_inkcpp_rb() {
+    Rice::Module rb_mInk = define_module("Ink");
+    rb_mInk.const_set(Rice::Identifier("VERSION"), Rice::String("0.1.0"));
+
+    Data_Type<ink::compiler::compilation_results> rb_cCompilationResults = define_class_under<ink::compiler::compilation_results>(rb_mInk, "CompilationResults")
+            .define_method("warnings", [](ink::compiler::compilation_results &results) {
+                    return results.warnings;
+                }, Return().takeOwnership())
+            .define_method("errors", [](ink::compiler::compilation_results &results) {
+                    return results.errors;
+                }, Return().takeOwnership());
+    rb_mInk.define_singleton_function("compile_file", [](std::string &in_file, std::string &out_file) {
+                ink::compiler::compilation_results * results = new ink::compiler::compilation_results();
+                ink::compiler::run(in_file.c_str(), out_file.c_str(), results);
+                return results;
+            }, Return().takeOwnership())
+            .define_singleton_function("compile_json", [](std::string &in_stream) {
+                std::istringstream istream(in_stream);
+                std::ostringstream ostream;
+                ink::compiler::compilation_results * results = new ink::compiler::compilation_results();
+                ink::compiler::run(istream, ostream, results);
+                delete results;
+                return ostream.str();
+            }, Return().takeOwnership());
+    Data_Type<choice> rb_cChoice = define_class_under<choice>(rb_mInk, "Choice")
+            .define_method("index", &choice::index)
+            .define_method("text", &choice::text)
+            .define_method("has_tags", &choice::has_tags)
+            .define_method("num_tags", &choice::num_tags)
+            .define_method("get_tag", &choice::get_tag);
+    Data_Type<snapshot> rb_cSnapshot = define_class_under<snapshot>(rb_mInk, "Snapshot")
+            .define_singleton_method("from_binary", [](const std::string & data){
+                return snapshot::from_binary((const unsigned char *)data.c_str(), data.length(), false);
+            }, Return().takeOwnership())
+            .define_singleton_method("from_file", &snapshot::from_file, Return().takeOwnership())
+            .define_method("get_data", &snapshot::get_data)
+            .define_method("get_data_len", &snapshot::get_data_len)
+            .define_method("num_runners", &snapshot::num_runners)
+            .define_method("write_to_file", &snapshot::write_to_file);
+    Data_Type<runner> rb_cRunner = define_class_under<runner>(rb_mInk, "Runner")
+            .define_method("set_rng_seed", &runner::set_rng_seed)
+            .define_method("can_continue", &runner::can_continue)
+            .define_method("choose", &runner::choose)
+            .define_method("has_tags", &runner::has_tags)
+            .define_method("num_tags", &runner::num_tags)
+            .define_method("num_choices", &runner::num_choices)
+            .define_method("get_tag", &runner::get_tag)
+            .define_method("move_to", [](runner &self, std::string &path) {
+                return self.move_to(ink::hash_string(path.c_str()));
+            })
+            .define_method("getline", [](runner &self) {
+                return self.getline();
+            }, Return().takeOwnership())
+            .define_method("create_snapshot", &runner::create_snapshot, Return().takeOwnership())
+            .define_method("getall", [](runner &self){
+                return self.getall();
+            }, Return().takeOwnership())
+            .define_iterator(&runner::begin, &runner::end, "each_choice")
+            .define_method("get_choice", &runner::get_choice)
+            .define_method("bind_void", [](runner &self, std::string &function_name, bound_func * callback, bool lookahead_safe){
+                self.bind(function_name.c_str(), [callback](size_t len, const value* vals) {
+			            std::vector args(vals, vals + len);
+                        return (*callback)(args);
+		        }, lookahead_safe);
+            })
+            .define_method("bind", [](runner &self, std::string &function_name, bound_func * callback, bool lookahead_safe){
+                self.bind(function_name.c_str(), [callback](size_t len, const value* vals) {
+			            std::vector args(vals, vals + len);
+                        return (*callback)(args);
+		        }, lookahead_safe);
+            }, Arg("function_name"), Arg("callback"), Arg("lookahead_safe") = false);
+    Data_Type<runner_ptr> rb_cRunnerImpl = define_class_under<runner_ptr>(rb_mInk, "RunnerImpl")
+            .define_method("get", [](runner_ptr &self) {
+                return self.get();
+            });
+
+    Data_Type<list::iterator::Flag> rb_cFlag = define_class_under<list::iterator::Flag>(rb_mInk, "Flag")
+            .define_attr("name", &list::iterator::Flag::flag_name, AttrAccess::Read)
+            .define_attr("list_name", &list::iterator::Flag::list_name, AttrAccess::Read);
+    list::iterator (list::*begin_ptr)() const = &list::begin;
+    list::iterator (list::*end_ptr)() const = &list::end;
+    Data_Type<list> rb_cList = define_class_under<list>(rb_mInk, "List")
+            .define_method("add", &list::add)
+            .define_method("remove", &list::remove)
+            .define_method("contains", &list::contains)
+            .define_method("to_s", &list_to_str, Return().takeOwnership())
+            .define_method("flags_from", [](list &self, std::string & list_name) {
+                std::vector<list::iterator::Flag> result;
+                for (list::iterator it = self.begin(list_name.c_str()); it != self.end(); ++it) {
+                    result.push_back(*it);
+                }
+                return result;
+            }, Return().takeOwnership())
+            .define_method("to_vec", [](list &self) {
+                std::vector<list::iterator::Flag> result;
+                for (const auto& flag : self) {
+                    result.push_back(flag);
+                }
+                return result;
+            }, Return().takeOwnership());
+    // Include enumerable support
+
+
+    Enum<value::Type> rb_cValueType = define_enum<value::Type>("ValueType", rb_mInk)
+            .define_value("INT32", value::Type::Int32)
+            .define_value("FLOAT", value::Type::Float)
+            .define_value("UINT32", value::Type::Uint32)
+            .define_value("STRING", value::Type::String)
+            .define_value("LIST", value::Type::List)
+            .define_value("BOOL", value::Type::Bool);
+    Data_Type<value> rb_cValue = define_class_under<value>(rb_mInk, "Value")
+            .define_singleton_function("from_int", [](int32_t num){
+                return value(num);
+            })
+            .define_singleton_function("from_bool", [](bool b){
+                return value(b);
+            })
+            .define_singleton_function("from_float", [](float f) {
+                return value(f);
+            })
+            .define_singleton_function("from_string", [](std::string & s) {
+                return value(s.c_str());
+            })
+            .define_singleton_function("from_uint", [](uint32_t num) {
+                return value(num);
+            })
+            .define_singleton_function("from_list", [](list & l) {
+                return value(&l);
+            })
+            .define_singleton_function("from_value", [](value & v) {
+                return value(v);
+            })
+            .define_attr("type", &value::type, Rice::AttrAccess::Read)
+            .define_method("to_s", [](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 std::runtime_error("value is in an invalid state");
+            })
+            .define_method("to_i", [](value &self) {
+                switch(self.type) {
+                    case value::Type::Bool: return int64_t(self.get<value::Type::Bool>() ? 1 : 0);
+                    case value::Type::Uint32: return int64_t(self.get<value::Type::Uint32>());
+                    case value::Type::Int32: return int64_t(self.get<value::Type::Int32>());
+                    case value::Type::String: return (int64_t) 0;
+                    case value::Type::Float: return int64_t (round(self.get<value::Type::Float>()));
+                    case value::Type::List: return (int64_t) 0;
+                }
+                throw std::runtime_error("value is in an invalid state");
+            })
+            .define_method("to_f", [](value &self) {
+                switch(self.type) {
+                    case value::Type::Bool: return double(self.get<value::Type::Bool>() ? 1 : 0);
+                    case value::Type::Uint32: return double(self.get<value::Type::Uint32>());
+                    case value::Type::Int32: return double(self.get<value::Type::Int32>());
+                    case value::Type::String: return (double) 0;
+                    case value::Type::Float: return double (self.get<value::Type::Float>());
+                    case value::Type::List: return (double) 0;
+                }
+                throw std::runtime_error("value is in an invalid state");
+            })
+            .define_method("to_list", [](value &self) {
+                if(self.type != value::Type::List) {
+                    throw std::runtime_error("Not a list");
+                }
+                return self.get<value::Type::List>();
+            });
+    Data_Type<globals> rb_cGlobals = define_class_under<globals>(rb_mInk, "Globals")
+            .define_method("[]", [](globals &self, std::string &key) {
+                const char * k = key.c_str();
+                auto res = self.get<value>(k);
+                if(!res.has_value()) {
+                    throw std::runtime_error("No value");
+                }
+                return res.value();
+            })
+            .define_method("[]=", [](globals &self, std::string &key, value &value) {
+                const char * k = key.c_str();
+                if(!self.set(k, value)) {
+                    throw std::runtime_error("Could not set");
+                }
+            });
+
+    Data_Type<story_ptr> rb_cStoryImpl = define_class_under<story_ptr>(rb_mInk, "StoryImpl")
+            .define_method("get", [](story_ptr &self) {
+                return self.get();
+            });
+    Data_Type<story> rb_cStory = define_class_under<story>(rb_mInk, "Story")
+            .define_singleton_function("from_file", &story::from_file, Return().takeOwnership())
+            .define_singleton_function("from_binary", [](std::string &data) {
+                    return story::from_binary((unsigned char *) data.c_str(), data.length(), false);
+                }, Return().takeOwnership())
+            .define_method("new_globals", &story::new_globals, Return().takeOwnership())
+            .define_method("new_runner", &story::new_runner, Arg("globals") = (story_ptr) nullptr, Return().takeOwnership())
+            .define_method("new_globals_from_snapshot", &story::new_globals_from_snapshot, Return().takeOwnership())
+            .define_method("new_runner_from_snapshot", &story::new_runner_from_snapshot, Arg("snapshot"), Arg("globals") = (story_ptr) nullptr, Arg("idx"), Return().takeOwnership());
+}

data/inkcpp_rb.gemspec

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+Gem::Specification.new do |spec|
+  spec.name = "inkcpp_rb"
+  spec.version = "0.1.0"
+  spec.authors = ["Chris Zelenak"]
+  spec.email = ["chris@zelenak.me"]
+  spec.licenses = ["MIT"]
+
+  spec.summary = "inkcpp bindings in Ruby"
+  spec.description = "inkcpp bindings in Ruby"
+  spec.homepage = "https://git.sr.ht/~netshade/inkcpp_rb"
+  spec.required_ruby_version = ">= 2.6.0"
+
+  spec.metadata["allowed_push_host"] = "https://rubygems.org/"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://git.sr.ht/~netshade/inkcpp_rb"
+  spec.metadata["changelog_uri"] = "https://git.sr.ht/~netshade/inkcpp_rb/tree/main/item/CHANGELOG.md"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  submodules = %w{inkcpp}
+  submodule_files = submodules.flat_map do |module_name|
+    base_submodule_path = File.join("ext", "inkcpp_rb", module_name)
+    submodule_path = File.join(File.expand_path(__dir__), base_submodule_path)
+    Dir.chdir(submodule_path) do
+      files = `git ls-files -z`.split("\x0").map { |module_file| File.join(base_submodule_path, module_file) }
+      raise "Submodule not checked out" if files.empty?
+      files
+    end
+  end
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (f == __FILE__) || f.match(%r{\A(?:(?:test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
+    end
+  end + submodule_files
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+  spec.extensions = ["ext/inkcpp_rb/extconf.rb"]
+
+  # Uncomment to register a new dependency of your gem
+  # spec.add_dependency "example-gem", "~> 1.0"
+  spec.add_development_dependency "rake-compiler", "~> 1.2.8"
+  spec.add_development_dependency "rice", "~> 4.3.3"
+  spec.add_development_dependency "sorbet", "~> 0.5.0"
+  spec.add_development_dependency "sorbet-runtime", "~> 0.5.0"
+  spec.add_development_dependency "tapioca", "~> 0.16.0"
+  spec.add_development_dependency "debug", "~> 1.1.0"
+
+  # For more information and examples about making a new gem, check out our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end

data/rbi/inkcpp_rb.rbi

@@ -0,0 +1,211 @@
+# typed: strict
+
+module Ink
+  class CompilationResults
+    sig { returns(T.untyped) }
+    def warnings; end
+
+    sig { returns(T.untyped) }
+    def errors; end
+  end
+
+  sig { params(in_file: String, out_file: String).returns(Ink::CompilationResults)}
+  def self.compile_file(in_file, out_file); end
+
+  sig { params(in_json: String).returns(String) }
+  def self.compile_json(in_json); end
+
+  class Flag
+    sig { returns(String) }
+    def name; end
+
+    sig { returns(String) }
+    def list_name; end
+  end
+  class Choice
+    sig { returns(Integer) }
+    def index; end
+
+    sig { returns(String) }
+    def text; end
+
+    sig { returns(T::Boolean) }
+    def has_tags; end
+
+    sig { returns(Integer) }
+    def num_tags; end
+
+    sig { params(index: Integer).returns(String) }
+    def get_tag(index); end
+  end
+  class List
+    sig { params(flag: String).void }
+    def add(flag); end
+
+    sig { params(flag: String).void }
+    def remove(flag); end
+
+    sig { params(flag: String).returns(T::Boolean) }
+    def contains(flag); end
+
+    sig { params(list_name: String).returns(T.untyped) }
+    def flags_from(list_name); end
+
+    sig { returns(T.untyped) }
+    def to_vec; end
+  end
+
+  class ValueType < T::Enum
+    enums do
+      INT32 = new
+      FLOAT = new
+      UINT32 = new
+      STRING = new
+      LIST = new
+      BOOL = new
+    end
+  end
+
+  class Value
+    sig { params(value: Integer).returns(Ink::Value) }
+    def self.from_int(value); end
+
+    sig { params(value: T::Boolean).returns(Ink::Value) }
+    def self.from_bool(value); end
+
+    sig { params(value: Float).returns(Ink::Value) }
+    def self.from_float(value); end
+
+    sig { params(value: String).returns(Ink::Value) }
+    def self.from_string(value); end
+
+    sig { params(value: Integer).returns(Ink::Value) }
+    def self.from_uint(value); end
+
+    sig { params(value: Ink::List).returns(Ink::Value) }
+    def self.from_list(value); end
+
+    sig { params(value: Ink::Value).returns(Ink::Value) }
+    def self.from_value(value); end
+
+    sig { returns(Ink::ValueType) }
+    def type; end
+
+    sig { returns(String) }
+    def to_s; end
+
+    sig { returns(Integer) }
+    def to_i; end
+
+    sig { returns(Float) }
+    def to_f; end
+
+    sig { returns(Ink::Value) }
+    def to_list; end
+  end
+
+  class Runner
+    sig { params(seed: Integer).void }
+    def set_rng_seed(seed); end
+
+    sig { returns(T::Boolean) }
+    def can_continue; end
+
+    sig { params(index: Integer).void }
+    def choose(index); end
+
+    sig { returns(T::Boolean) }
+    def has_tags; end
+
+    sig { returns(Integer) }
+    def num_tags; end
+
+    sig { returns(Integer) }
+    def num_choices; end
+
+    sig { params(index: Integer).returns(String) }
+    def get_tag(index); end
+
+    sig { params(path: String).returns(T::Boolean) }
+    def move_to(path); end
+
+    sig { returns(String) }
+    def getline; end
+
+    sig { returns(Ink::Snapshot) }
+    def create_snapshot; end
+
+    sig { returns(String) }
+    def getall; end
+
+    sig { returns(T::Enumerable[Ink::Choice]) }
+    def each_choice; end
+
+    sig { params(index: Integer).returns(Ink::Choice) }
+    def get_choice(index); end
+
+    sig { params(name: String, callback: T.proc.params(argsVec: T.untyped).void, lookahead_safe: T::Boolean).void }
+    def bind_void(name, callback, lookahead_safe); end
+
+    sig { params(name: String, callback: T.proc.params(argsVec: T.untyped).returns(Ink::Value), lookahead_safe: T::Boolean).void }
+    def bind(name, callback, lookahead_safe); end
+  end
+
+  class Globals
+    sig { params(key: String).returns(T.nilable(Ink::Value)) }
+    def [](key); end
+
+    sig { params(key: String, value: Ink::Value).void }
+    def []=(key, value); end
+  end
+
+  class Snapshot
+    sig { params(data: String).returns(Ink::Snapshot) }
+    def self.from_binary(data); end
+
+    sig { params(file: String).returns(Ink::Snapshot) }
+    def self.from_file(file); end
+
+    sig { returns(String) }
+    def get_data; end
+
+    sig { returns(Integer) }
+    def get_data_len; end
+
+    sig { returns(Integer) }
+    def num_runners; end
+
+    sig { params(file: String).void }
+    def write_to_file(file); end
+  end
+
+  class RunnerImpl
+    sig { returns(T.nilable(Ink::Runner)) }
+    def get; end
+  end
+
+  class StoryImpl
+    sig { returns(T.nilable(Ink::Globals)) }
+    def get; end
+  end
+
+  class Story
+    sig { params(story: String).returns(T.nilable(Ink::Story)) }
+    def self.from_file(story); end
+
+    sig { params(data: String).returns(T.nilable(Ink::Story)) }
+    def self.from_binary(data); end
+
+    sig { returns(T.nilable(Ink::StoryImpl)) }
+    def self.new_globals(); end
+
+    sig { params(globals: T.nilable(Ink::StoryImpl)).returns(Ink::RunnerImpl) }
+    def self.new_runner(globals); end
+
+    sig { params(snapshot: Ink::Snapshot).returns(Ink::StoryImpl) }
+    def self.new_globals_from_snapshot(snapshot); end
+
+    sig { params(snapshot: Ink::Snapshot, globals: T.nilable(Ink::StoryImpl), index: Integer).returns(Ink::StoryImpl) }
+    def self.new_runner_from_snapshot(snapshot, globals, index); end
+  end
+end

data/sorbet/config

@@ -0,0 +1,4 @@
+--dir
+.
+--ignore=tmp/
+--ignore=vendor/

data/sorbet/rbi/annotations/.gitattributes

@@ -0,0 +1 @@
+**/*.rbi linguist-vendored=true