ruble 0.0.3.alpha

data/ext/ruble/utils/hexadecimal.hpp

@@ -0,0 +1,116 @@
+#pragma once
+
+#include "types/declarations.hpp"
+
+#include <cstddef>
+#include <string>
+#include <iostream>
+#include <memory>
+#include <type_traits>
+#include <format>
+#include <ranges>
+#include <boost/algorithm/hex.hpp>
+
+namespace RuBLE::Utils {
+    namespace Hexadecimal {
+        namespace ranges = std::ranges;
+        namespace views = std::views;
+        using namespace std::string_view_literals;
+
+        constexpr const auto hex_string_prefix = "0x"sv;
+        constexpr const auto hex_prefix_len = hex_string_prefix.length();
+
+        // Testing:
+        template <bool prefix, std::integral T>
+        std::string to_hex_string(const T &num);
+        template <bool prefix, typename T> requires std::is_pointer_v<T>
+        std::string to_hex_addr(const T &ptr);
+        template <bool prefix, typename T>
+        std::string to_hex_addr(const std::shared_ptr<T> &ptr);
+        template <bool prefix, typename T> requires std::is_base_of_v<Rice::Object, T>
+        std::string to_hex_addr(const T &obj);
+        template <bool prefix, typename T>
+        std::string to_hex_addr(const T &obj);
+        template<bool prefix, ranges::viewable_range T>
+        [[maybe_unused]] std::string to_hex_data(const T &t);
+        template<bool prefix, class T>
+        [[maybe_unused]] std::string to_hex_data(const T &t);
+        // End Testing
+
+        template <bool prefix = true, std::integral T = void>
+        std::string ref_to_hex_string(const T &num) {
+            constexpr std::size_t result_len = std::max(std::size_t(2), sizeof (T) * 2) + (prefix ? 2 : 0);
+            constexpr const auto fmt_str = prefix ? "{:#0{}x}" : "{:0{}x}";
+            return std::format(fmt_str, num, result_len);
+        }
+
+        template <bool prefix = true, typename T = void> requires std::is_pointer_v<T>
+        std::string ptr_to_hex_addr(const T &ptr) {
+            return to_hex_string<prefix>(reinterpret_cast<uintptr_t>(std::to_address(ptr)));
+        }
+
+        template <bool prefix = true, typename T = void>
+        std::string sptr_to_hex_addr(const std::shared_ptr<T> &ptr) {
+            return to_hex_addr<prefix>(ptr.get());
+        }
+
+        template <bool prefix = true, typename T = void> requires std::is_base_of_v<Rice::Object, T>
+        std::string rb_to_hex_addr(const T &obj) {
+            return to_hex_string<prefix>(obj.value());
+        }
+
+        template <bool prefix = true, typename T = void>
+        std::string ref_to_hex_addr(const T &obj) {
+            return to_hex_addr<prefix>(&obj);
+        }
+
+        template<bool prefix = true, ranges::viewable_range T = void>
+        std::string range_to_hex_data(const T &t) {
+            constexpr std::size_t prefix_len = prefix ? hex_prefix_len : 0;
+            constexpr auto null_byte = static_cast<std::byte>(0);
+            constexpr auto is_null = [](const std::byte &b) { return null_byte == b; };
+
+            // we can't simply use `std::as_bytes(t) | views::transform | views::join` due to
+            // https://en.cppreference.com/mwiki/index.php?title=cpp/ranges/join_view&oldid=155702#Notes
+
+            std::string output = prefix ? std::string(hex_string_prefix) : "";
+            auto span = std::span(t.begin(), t.end());
+
+            constexpr auto byte_to_int = [](const std::byte &byte) -> uint8_t {
+                return std::to_integer<uint8_t>(byte);
+            };
+
+            auto in = std::as_bytes(span) | views::drop_while(is_null) | views::transform(byte_to_int);
+            boost::algorithm::hex_lower(in.begin(), in.end(), std::back_inserter(output));
+
+            std::size_t moved_hex_pairs = output.length() - prefix_len;
+
+            if (moved_hex_pairs == 0) output.append("00");
+            return output;
+        }
+
+        template<bool prefix = true, class T>
+        std::string ref_to_hex_data(const T &t) {
+            auto span = std::span(&t, 1);
+            return to_hex_data<prefix, decltype(span)>(span);
+        }
+
+        // Testing:
+        template <bool prefix = true, std::integral T = void>
+        std::string to_hex_string(const T &num) { return ref_to_hex_string(num); }
+        template <bool prefix = true, typename T = void> requires std::is_pointer_v<T>
+        std::string to_hex_addr(const T &ptr) { return ptr_to_hex_addr(ptr); }
+        template <bool prefix = true, typename T = void>
+        std::string to_hex_addr(const std::shared_ptr<T> &ptr) { return sptr_to_hex_addr(ptr); }
+        template <bool prefix = true, typename T = void> requires std::is_base_of_v<Rice::Object, T>
+        std::string to_hex_addr(const T &obj) { return rb_to_hex_addr(obj); }
+        template <bool prefix = true, typename T = void>
+        std::string to_hex_addr(const T &obj) { return ref_to_hex_addr(obj); }
+        template<bool prefix = true, ranges::viewable_range T>
+        [[maybe_unused]] std::string to_hex_data(const T &t) { return range_to_hex_data(t); }
+        template<bool prefix = true, class T>
+        [[maybe_unused]] std::string to_hex_data(const T &t) { return ref_to_hex_data(t); }
+    } // Hexadecimal
+    using namespace Hexadecimal;
+} // RuBLE::Utils
+

data/ext/ruble/utils/human_type_names.hpp

@@ -0,0 +1,38 @@
+#pragma once
+
+#include <string>
+#include <typeinfo>
+#include <type_traits>
+#include <concepts>
+#include <any>
+#include <boost/core/demangle.hpp>
+#include <iostream>
+
+#include <rice/rice.hpp>
+#include <rice/stl.hpp>
+
+
+namespace RuBLE::Utils {
+    namespace HumanTypeNames {
+        using boost::core::demangle;
+
+        // need to predeclare, since the templated fns call the fully specified version
+        template<typename T>
+        constexpr std::string human_type_name();
+
+        template<typename T> //requires (!std::convertible_to<T, const std::type_info&>)
+        constexpr std::string human_type_name(const T &) { return human_type_name<T>(); }
+
+        template<typename = void>
+        constexpr std::string human_type_name(const std::type_info &type) {
+            return demangle(type.name());
+        }
+
+        template<typename T>
+        constexpr std::string human_type_name() { return human_type_name(typeid(T)); }
+
+        template<>
+        [[maybe_unused]] constexpr std::string human_type_name(const std::any &any) { return human_type_name(any.type()); }
+    }
+    using namespace HumanTypeNames;
+} // RuBLE::Utils

data/ext/ruble/utils/inspection.cpp

@@ -0,0 +1,24 @@
+#include "inspection.hpp"
+
+namespace RuBLE::Utils::Inspection {
+    [[maybe_unused]] std::string basic_object_inspect_start(const Rice::Object &o) {
+            std::ostringstream oss;
+            oss << "#<" << o.class_name();
+            oss << ":" << to_hex_string(reinterpret_cast<uint64_t>(o.value()));
+            return oss.str();
+        }
+        std::string ruby_quote_string(const std::string &str) {
+            return ensure_ruby<std::string>([&str]() -> std::string {
+                Object obj = Object(rb_cString).call("new", str);
+                return ruby_inspect(obj);
+            });
+        }
+
+        std::string ruby_inspect(Rice::Object obj) {
+            auto fn = [&obj]() -> std::string {
+                VALUE rb_str = obj.call("inspect").value();
+                return Rice::String(rb_str).str();
+            };
+            return ensure_ruby<std::string>(fn);
+        }
+}

data/ext/ruble/utils/inspection.hpp

@@ -0,0 +1,108 @@
+#pragma once
+
+#include "types/declarations.hpp"
+#include "types/ruby.hpp"
+#include "types/SimpleBLE.hpp"
+#include "utils/human_type_names.hpp"
+#include "utils/hexadecimal.hpp"
+#include <boost/describe.hpp>
+#include <boost/describe/enum.hpp>
+#include <boost/describe/enum_to_string.hpp>
+#include <boost/describe/enumerators.hpp>
+#include <boost/describe/modifier_description.hpp>
+
+namespace SimpleBLE {
+    BOOST_DESCRIBE_ENUM(
+        BluetoothAddressType,
+        PUBLIC,
+        RANDOM,
+        UNSPECIFIED
+    )
+}
+using boost::describe::boost_enum_descriptor_fn;
+
+namespace RuBLE::Utils {
+    namespace Inspection {
+        std::string ruby_inspect(Object obj);
+
+        std::string ruby_quote_string(const std::string &str);
+
+        // From https://www.boost.org/doc/libs/1_83_0/libs/describe/doc/html/describe.html#example_printing_enums_rt
+        template<class Enum_T> requires std::is_enum_v<Enum_T>
+        struct enumerator_trait { const Enum_T value; const std::string name; };
+
+        template<class Enum_T> requires std::is_enum_v<Enum_T>
+        constexpr auto enumerator_traits_as_array() {
+            constexpr auto impl = []<template<class... T> class L, class... T>( L<T...> ) ->
+                    std::array<enumerator_trait<Enum_T>, sizeof...(T)> {
+                return { { { T::value, T::name }... } };
+            };
+            return impl(boost::describe::describe_enumerators<Enum_T>());
+        }
+
+        template<typename Enum_T> requires std::is_enum_v<Enum_T>
+        Rice::Enum<Enum_T> define_described_enum(char const* name, Rice::Module &module) {
+            using Enum_DT = Rice::Enum<Enum_T>;
+            Enum_DT rb_type = define_enum<Enum_T>(name, module);
+
+            const auto traits = enumerator_traits_as_array<Enum_T>();
+            for (const enumerator_trait<Enum_T> &item : traits) rb_type.define_value(item.name, item.value);
+            return rb_type;
+        }
+
+        template<typename Enum_T> requires std::is_enum_v<Enum_T>
+        Rice::Enum<Enum_T> define_described_enum(Rice::Module &module) {
+            return define_described_enum(human_type_name<Enum_T>(), module);
+        }
+
+        template<typename Enum_T>
+        requires std::is_enum_v<Enum_T>
+        std::string enum_rb_type_name(const Enum_T &enumVal) {
+            Object rbEnumItem = Rice::detail::To_Ruby<Enum_T>().convert(enumVal);
+            return rbEnumItem.class_name().str();
+        }
+
+        template<typename Enum_T>
+        requires std::is_enum_v<Enum_T>
+        std::string enum_val_as_string(const Enum_T &enumVal) {
+            constexpr const char *fallback = "(unrecognized)";
+            return boost::describe::enum_to_string<Enum_T>(enumVal, fallback);
+        }
+
+        template<typename Enum_T>
+        requires std::is_enum_v<Enum_T>
+        [[maybe_unused]] std::string enum_val_inspect(const Enum_T &enumVal) {
+            return enum_rb_type_name(enumVal) + "::" + enum_val_as_string(enumVal);
+        }
+
+        // split out the closing '>' into its own function to make enhancing this method easier
+        [[maybe_unused]] std::string basic_object_inspect_start(const Rice::Object &o);
+
+//        template <HasRubyObject T>
+//        std::string basic_object_inspect_start(T &t) {
+//            Object obj = t.self();
+//            return basic_object_inspect_start(obj);
+//        }
+
+        template<class T>
+        // requires (!HasRubyObject<T>)
+        constexpr std::string basic_object_inspect_start(T &t) {
+            std::ostringstream oss;
+            oss << "#<" << human_type_name<T>() << ":" << to_hex_addr<true, T>(t);
+            return oss.str();
+        }
+
+        [[maybe_unused]] constexpr std::string basic_object_inspect(auto &o) {
+            return basic_object_inspect_start(o) + ">";
+        }
+    } // Inspection
+    using namespace Inspection;
+} // RuBLE::Utils
+
+template<typename Key, class ProxyClass, class Value>
+constexpr std::ostream &operator<<(std::ostream &os, const RuBLE::Registry<Key, ProxyClass, Value> &reg) {
+    return os << reg.to_s();
+}
+
+template<const auto &FIELDS>
+constexpr std::ostream &operator<<(std::ostream &os, const RuBLE::NamedBitSet<FIELDS> &nbs) { return os << nbs.to_s(); }

data/ext/ruble/utils/ruby.hpp

@@ -0,0 +1,103 @@
+#pragma once
+
+#include "types/ruby.hpp"
+#include "utils/ruby_context.hpp"
+#include "utils/exception_handling.hpp"
+//#include "types/stl.hpp"
+#include <ruby/thread.h>
+#include <memory>
+#include <functional>
+
+namespace RuBLE {
+    namespace Utils::Ruby {
+        template <typename T, typename Fn = std::function<T()>>
+        T ensure_ruby(const Fn &fn) {
+            if (in_ruby) return fn();
+            RbThreadCallFn<> invoke = [](void *fnPtr) -> void * {
+                volatile auto in_ruby_guard = in_ruby.assert_in_ruby_guard();
+                auto &fnRef = *reinterpret_cast<Fn *>(fnPtr);
+                return new T(std::move(fnRef()));
+            };
+            void *resultPtrVoid = rb_thread_call_with_gvl(invoke, const_cast<std::remove_const_t<Fn>*>(&fn));
+            T *resultPtr = reinterpret_cast<T*>(resultPtrVoid);
+            T &&result = std::move(*resultPtr);
+            delete resultPtr;
+            return std::move(result);
+        }
+
+        template <typename T, typename... Args>
+        [[maybe_unused]] T ensuring_ruby(std::function<T(Args...)> &&fn, Args &&...args) {
+            auto wrapper = [&fn, &args...]() -> T { return std::invoke(fn, args...); };
+            return ensure_ruby<T>(wrapper);
+        }
+
+        template <typename T, typename... Args>
+        T cpp_protect(std::function<T(Args...)> &&fn, Args &&...args) {
+            auto wrapper = [&fn, &args...]() -> T {
+                try {
+                    return std::invoke(fn, args...);
+                } catch (const std::exception &ex) {
+                    ExceptionHandling::throw_with_backtrace(ex);
+                }
+            };
+            return Rice::detail::cpp_protect(wrapper);
+        }
+
+        [[maybe_unused]] constexpr VALUE to_ruby_value(const VALUE &val) { return val; }
+
+        [[maybe_unused]] constexpr VALUE to_ruby_value(const RiceObject auto &obj) { return obj.value(); }
+
+        [[maybe_unused]] constexpr VALUE to_ruby_value(const HasRubyObject auto &obj) { return obj.self(); }
+        constexpr VALUE to_ruby_value(const HasRubyObject auto *obj) { return to_ruby_value(*obj); }
+
+        template <class T> requires HasRubyObject<typename T::element_type> &&
+                                    std::same_as<std::shared_ptr<typename T::element_type>, T>
+        constexpr VALUE to_ruby_value(const T &obj) { return to_ruby_value(*obj); }
+
+        template <RiceObject T = Rice::Object>
+        [[maybe_unused]] constexpr T to_ruby_object(const auto &val) { return T { to_ruby_value(val) }; }
+
+#if false
+        // TODO: test me!
+        template <typename T, typename... Args>
+        RubyThreadId ruby_thread_create(std::function<T(Args...)> &&fn, Args &&...args) {
+            using FnT = std::function<void()>;
+            FnT invoker = [&fn, &args...]() { std::invoke(fn, args...); };
+            constexpr RbThreadCreateFn<void> wrapper = [](void *ptr) -> VALUE  {
+                FnT invoker = *reinterpret_cast<FnT*>(ptr);
+                invoker();
+                return Qnil;
+            };
+            RubyThreadId tid = rb_thread_create(wrapper, &invoker);
+            return tid;
+        }
+
+//        TODO: See if we can figure out how to get this to work (see https://stackoverflow.com/q/28746744)
+//        template <typename T = void>
+//        VALUE ruby_thread_create(RbThreadCreateFn<T> fn, T *arg = nullptr) {
+//            constexpr RbThreadCreateFn<void> wrapper = [&fn](void *ptr) -> VALUE  {
+//                return fn(reinterpret_cast<T*>(ptr));
+//            };
+//            return rb_thread_create(wrapper, arg);
+//        }
+//
+//
+//        template <typename T = void, typename Ret = void, typename UbfArgT = void>
+//        Ret *ruby_thread_call_without_gvl(RbThreadCallFn<Ret, T> fn,
+//                                          T *arg = nullptr,
+//                                          RbUbfFn<UbfArgT> &ubf = nullptr,
+//                                          UbfArgT *ubfArg = nullptr) {
+//            RbThreadCreateFn<void> wrapper = [&fn](void *ptr) -> void * {
+//                return fn(reinterpret_cast<T*>(ptr));
+//            };
+//            RbUbfFn<void> ubfWrapper = [&ubf](void *ptr) -> void {
+//                return ubf(reinterpret_cast<T*>(ptr));
+//            };
+//            void *ret = rb_thread_call_without_gvl(wrapper, arg, ubf, ubfWrapper);
+//            return reinterpret_cast<Ret*>(ret);
+//        }
+#endif
+    }
+    namespace Ruby = Utils::Ruby;
+    using Utils::Ruby::ensure_ruby;
+}

data/ext/ruble/utils/ruby_context.hpp

@@ -0,0 +1,73 @@
+#pragma once
+
+#include <cstdint>
+#include <utility>
+
+namespace RuBLE::Utils::Ruby::Context {
+    class InRuby;
+    class InRubyGuard {
+        InRuby *_inRuby = nullptr;
+
+        [[maybe_unused]] constexpr InRubyGuard(InRuby &inRuby);
+    public:
+        constexpr InRubyGuard() = default;
+        constexpr InRubyGuard(const InRubyGuard&) = delete;
+        constexpr InRubyGuard &operator=(const InRubyGuard&) = delete;
+        constexpr InRubyGuard(InRubyGuard&&) noexcept ;
+        constexpr InRubyGuard &operator=(InRubyGuard&&) noexcept ;
+        constexpr ~InRubyGuard();
+        constexpr operator bool() const { return _inRuby != nullptr; }
+
+        friend class InRuby;
+    };
+
+    class InRuby {
+    private:
+        uint64_t _use_count = 0;
+    public:
+        using Guard = InRubyGuard;
+        constexpr InRuby() = default;
+        InRuby(const InRuby &) = delete;
+        InRuby(InRuby &&) = delete;
+        InRuby &operator=(InRuby &&) = delete;
+        InRuby &operator=(const InRuby &) = delete;
+
+        // similar to lock_guard: this->state() will return true
+        // as long as at least one result of the assert_in_ruby_guard fn is maintained
+        constexpr Guard assert_in_ruby_guard() {
+            return { *this };
+        }
+        [[nodiscard]] constexpr const auto &use_count() const { return _use_count; }
+        [[nodiscard]] constexpr bool state() const { return use_count() > 0; }
+        constexpr operator bool() const { return state(); }
+        friend class InRubyGuard;
+    };
+
+    [[maybe_unused]] constexpr InRubyGuard::InRubyGuard(InRuby &inRuby) : _inRuby(&inRuby) {
+        if (_inRuby != nullptr) ++_inRuby->_use_count;
+    }
+    constexpr InRubyGuard::~InRubyGuard() {
+        if (_inRuby != nullptr) --_inRuby->_use_count;
+    }
+
+    constexpr InRubyGuard::InRubyGuard(InRubyGuard &&other) noexcept {
+        *this = std::move(other);
+    }
+
+    constexpr InRubyGuard &InRubyGuard::operator=(InRubyGuard &&other) noexcept {
+        InRuby *old = std::exchange(_inRuby, other._inRuby);
+        if (_inRuby != nullptr) ++_inRuby->_use_count;
+        if (old != nullptr) --old->_use_count;
+        other._inRuby = nullptr;
+        return *this;
+    }
+}
+
+namespace RuBLE {
+    namespace Utils {
+        namespace RubyContext = Ruby::Context;
+    }
+    namespace RubyContext = Utils::RubyContext;
+    using RubyContext::InRuby;
+    extern thread_local InRuby in_ruby;
+}

data/lib/ruble/build/.rubocop.yml

@@ -0,0 +1,19 @@
+inherit_from:
+  - ../../../.rubocop.yml
+
+AllCops:
+  include:
+    - '**/*.rb'
+  ActiveSupportExtensionsEnabled: true
+
+Metrics/CyclomaticComplexity:
+  Enabled: false
+
+Metrics/PerceivedComplexity:
+  Enabled: false
+
+Metrics/ClassLength:
+  Enabled: false
+
+Style/RescueModifier:
+  Enabled: false

data/lib/ruble/build/boost.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RuBLE
+  module Build
+    class Boost < GithubRepo
+      GITHUB_REPO = 'boostorg/boost'
+      OS_ARCHIVE_EXT = {
+        # ** = TODO: confirm standard tools on this OS support these
+        /\Alinux/                => 'tar.xz',
+        /\A(macos|darwin)/       => 'tar.xz', # **
+        /\A(ms)?win(32|64|dows)/ => '7z',     # **
+        /\Amingw|msys/           => 'tar.gz', # **
+        :fallback                => 'tar.gz', # **
+      }.freeze
+
+      memoize def asset_extension
+        OS_ARCHIVE_EXT.detect do |_k, v|
+          OS.host_os === v # rubocop:disable Style/CaseEquality
+        end&.first || OS_ARCHIVE_EXT.fetch(:fallback)
+      end
+
+      # Static makes sense for distribution if we can do it
+      memoize def asset_filename = "#{release_name}.#{asset_extension}".freeze
+      memoize def matching_asset = assets.fetch(asset_filename).freeze
+      memoize def extract_src_path = '[UNUSED]'
+
+      memoize def config_data
+        super.dup.tap do |data|
+          data[:archive_path] = extract_src_path
+        end.freeze
+      end
+    end
+  end
+end

data/lib/ruble/build/cmake.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require 'debug'
+module RuBLE
+  module Build
+    module CMake
+      CMAKE_LITERALS = {
+        nil   => 'NULL',
+        true  => 'ON',
+        false => 'OFF',
+      }.freeze
+      CMAKE_KEY_SEPARATOR = '_'
+      STRINGY_TYPES = [ String, Symbol, Pathname ].freeze
+
+      def cmake_generate(data, path: nil)
+        enum = cmake_serialized_enumerator(data)
+        return enum.reduce(String.new) do |memo, obj|
+          memo << "\n" unless memo.empty?
+          memo << obj
+        end unless path
+
+        path = Pathname.new(path)
+        path.open(File::WRONLY|File::CREAT) do |f|
+          # f.sync = true
+          enum.each { |field| f.puts(field) }
+        end
+        path
+      end
+
+      def cmake_serialize(value)
+        if value.is_a?(Array)
+          array = cmake_serialize_array(value)
+          array.map { cmake_escape(_1, quote: true) }.join(' ')
+        elsif value.is_any_of?(*STRINGY_TYPES)
+          cmake_escape(value.to_s)
+        elsif CMAKE_LITERALS.key?(value)
+          CMAKE_LITERALS[value]
+        elsif value.is_a?(Numeric)
+          value.to_s # no escaping necessary
+        else
+          raise ArgumentError, "Unrecognized value #{value.inspect}"
+        end
+      end
+
+      def cmake_serializable?(value)
+        value.is_any_of?(Array, Hash, *STRINGY_TYPES, Numeric) || CMAKE_LITERALS.key?(value)
+      end
+
+    private
+
+      def cmake_escape(str, quote: true)
+        result = str.gsub(/[\\"$]/) do |match|
+          %{\\#{match[0]}}
+        end
+        quote ? %{"#{result}"} : result
+      end
+
+      def cmake_serialized_enumerator(data)
+        cmake_flatten_hash(data).lazy.map do |k, v|
+          %{set(#{k} #{cmake_serialize(v)})}
+        end
+      end
+
+      def cmake_serialize_array(array)
+        elements = array.compact
+        unless elements.all? { _1.is_any_of?(*STRINGY_TYPES, Numeric) }
+          debugger if defined?(debugger)
+          raise ArgumentError, 'Array must contain only String-y elements'
+        end
+        elements
+      end
+
+      def cmake_flatten_hash(hash)
+        final = {}
+        hash = hash.dup if hash.frozen?
+        until hash.empty?
+          hash.transform_keys!(&:to_s)
+
+          # Join arrays and make stringy values `String`s
+          hash.transform_values! do |value|
+            next value unless value.is_any_of?(Array, *STRINGY_TYPES)
+            next value.to_s unless value.is_a?(Array) # if stringy, just make it a string
+
+            value.map(&:to_s)
+          end
+          hash.select { _2.is_a?(Array) }.keys.each do |k|
+            if final.key?(k)
+              warn "Duplicate hash key #{k.inspect}. Ignoring new value"
+              next
+            end
+            final[k] = hash.delete(k)
+          end
+
+          unrecognized_keys = hash.reject { |_k, v| cmake_serializable?(v) }.keys
+          if unrecognized_keys.any?
+            raise ArgumentError, "Unrecognized values in hash at keys #{unrecognized_keys}"
+          end
+
+          # Flatten hashes
+          hash_keys = hash.select { |_k, v| v.is_a?(Hash) }.keys
+          hash_keys.each do |k|
+            subhash = hash.delete(k)
+            subhash = subhash.dup if subhash.frozen?
+
+            flat_subhash = cmake_flatten_hash(subhash)
+            flat_subhash.transform_keys! { [k, _1].join(CMAKE_KEY_SEPARATOR) }
+            hash.merge!(flat_subhash) do |k, old_val, _new_val|
+              warn "Duplicate hash key #{k.inspect}. Ignoring new value"
+
+              old_val
+            end
+          end
+
+          # Move completed keys into `final` hash
+          completed_keys = hash.select do |_k, v|
+            v.is_any_of?(String, Numeric) || CMAKE_LITERALS.include?(v)
+          end.keys
+
+          completed_keys.each do |k|
+            v = hash.delete(k)
+            if final.key?(k)
+              warn "Duplicate hash key #{k.inspect}. Ignoring new value"
+              next
+            end
+
+            final[k] = v
+          end
+        end
+
+        final
+      end
+    end
+  end
+end

data/lib/ruble/build/core_ext.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Kernel
+  def is_any_of?(*klasses) = klasses.any? { is_a?(_1) }
+end

data/lib/ruble/build/data/bundler.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module RuBLE
+  module Build
+    module Data
+      module Bundler
+        # Based on https://www.rubydoc.info/gems/bundler/Bundler%2FEnv%2Eenvironment
+        include Memery
+
+        memoize def bundler_data
+          {
+            platform:         Gem.platforms.map(&:to_s),
+            config_dir:       Pathname.new(Gem::ConfigFile::SYSTEM_WIDE_CONFIG_FILE).dirname,
+            rubygems_version: Gem::VERSION,
+            gem_home:         Pathname.new(Gem.dir),
+            gem_path:         Gem.path.join(File::PATH_SEPARATOR),
+            user_home:        Pathname.new(Gem.user_dir),
+            bindir:           Pathname.new(Gem.bindir),
+          }.freeze
+        end
+      end
+    end
+  end
+end