qml 0.0.1

data/ext/qml/rubyvalue.h

@@ -0,0 +1,256 @@
+#pragma once
+#include "util.h"
+#include <ruby.h>
+#include <array>
+
+class QVariant;
+
+namespace RubyQml {
+
+namespace detail {
+template <typename T, typename Enable = void> struct Conversion
+{
+    static T from(RubyValue x);
+    static RubyValue to(typename std::conditional<std::is_scalar<T>::value, T, const T &>::type str);
+};
+
+}
+
+#define RUBYQML_INTERN(str) \
+    [] { static auto id = rb_intern(str); return id; }()
+
+class RubyModule;
+
+class RubyValue
+{
+public:
+    RubyValue() = default;
+    RubyValue(VALUE value) : mValue(value) {}
+
+    template <typename T> static RubyValue from(const T &value)
+    {
+        return detail::Conversion<T>::to(value);
+    }
+
+    template <typename T> T to() const
+    {
+        return detail::Conversion<T>::from(*this);
+    }
+
+    operator VALUE() const { return mValue; }
+
+    template <typename ... TArgs>
+    RubyValue send(ID method, TArgs ... args) const
+    {
+        constexpr int argc = sizeof...(args);
+        std::array<VALUE, argc> argv = {{ VALUE(args)... }};
+        return protect([&] {
+            return rb_funcall2(mValue, method, argc, argv.data());
+        });
+    }
+
+    template <typename ... TArgs>
+    RubyValue send(const char *method, TArgs ... args) const
+    {
+        return send(rb_intern(method), args...);
+    }
+
+    bool operator==(const RubyValue &other) const { return mValue == other.mValue; }
+    bool operator!=(const RubyValue &other) const { return !operator==(other); }
+    explicit operator bool() const { return RTEST(mValue); }
+
+    bool isKindOf(const RubyModule &module) const;
+    bool isConvertibleTo(int metaType) const;
+    int defaultMetaType() const;
+
+    static RubyValue fromVariant(const QVariant &value);
+    QVariant toVariant() const;
+    QVariant toVariant(int type) const;
+    static RubyValue fromQObject(QObject *obj, bool implicit = true);
+    QObject *toQObject() const;
+
+    ID toID() const;
+    static RubyValue fromID(ID id) { return ID2SYM(id); }
+
+    static void addEnumeratorMetaType(int metaType);
+
+private:
+    volatile VALUE mValue = Qnil;
+};
+
+namespace detail {
+
+template <>
+struct Conversion<RubyValue>
+{
+    static RubyValue from(RubyValue x) { return x; }
+    static RubyValue to(RubyValue x) { return x; }
+};
+
+template <>
+struct Conversion<bool>
+{
+    static bool from(RubyValue value) { return value; }
+    static RubyValue to(bool x) { return x ? Qtrue : Qfalse; }
+};
+
+// signed integers
+
+template <typename T>
+struct Conversion<T, typename std::enable_if<std::is_signed<T>::value && std::is_integral<T>::value>::type>
+{
+    static T from(RubyValue x)
+    {
+        return protect([&] {
+            return NUM2LL(x);
+        });
+    }
+    static RubyValue to(T x)
+    {
+        return LL2NUM(x);
+    }
+};
+
+// unsigned integers
+
+template <typename T>
+struct Conversion<T, typename std::enable_if<std::is_unsigned<T>::value && std::is_integral<T>::value>::type>
+{
+    static T from(RubyValue x)
+    {
+        return protect([&] {
+            return NUM2ULL(x);
+        });
+    }
+    static RubyValue to(T x)
+    {
+        return ULL2NUM(x);
+    }
+};
+
+// floating point values
+
+template <typename T>
+struct Conversion<T, typename std::enable_if<std::is_floating_point<T>::value>::type>
+{
+    static T from(RubyValue x)
+    {
+        return protect([&] {
+            auto type = rb_type(x);
+            if (type == T_FIXNUM || type == T_BIGNUM) {
+                return double(NUM2LL(x));
+            } else {
+                return rb_float_value(x);
+            }
+        });
+    }
+    static RubyValue to(T x)
+    {
+        return rb_float_new(x);
+    }
+};
+
+// QList and QVector
+
+template <class T> struct IsQListLike : std::false_type {};
+template <class V> struct IsQListLike<QList<V>> : std::true_type {};
+template <class V> struct IsQListLike<QVector<V>> : std::true_type {};
+
+template <template<class> class T, class V>
+struct Conversion<T<V>, typename std::enable_if<IsQListLike<T<V>>::value>::type>
+{
+    static T<V> from(RubyValue x)
+    {
+        protect([&] {
+            x = rb_convert_type(x, T_ARRAY, "Array", "to_ary");
+        });
+        int length = RARRAY_LEN(VALUE(x));
+        T<V> list;
+        list.reserve(length);
+        for (int i = 0; i < length; ++i) {
+            list << RubyValue(RARRAY_AREF(VALUE(x), i)).to<V>();
+        }
+        return list;
+    }
+    static RubyValue to(const T<V> &list)
+    {
+        RubyValue ary = protect([&] {
+            return rb_ary_new();
+        });
+        for (const auto &elem : list) {
+            auto x = RubyValue::from(elem);
+            protect([&] {
+                rb_ary_push(ary, x);
+            });
+        }
+        return ary;
+    }
+};
+
+// QHash and QMap
+
+template <class T> struct IsQHashLike : std::false_type {};
+template <class K, class V> struct IsQHashLike<QHash<K, V>> : std::true_type {};
+template <class K, class V> struct IsQHashLike<QMap<K, V>> : std::true_type {};
+
+template <template<class, class> class T, class K, class V>
+struct Conversion<T<K, V>, typename std::enable_if<IsQHashLike<T<K, V>>::value>::type>
+{
+    static T<K, V> from(RubyValue x)
+    {
+        protect([&] {
+            x = rb_convert_type(x, T_HASH, "Hash", "to_hash");
+        });
+        T<K, V> hash;
+        protect([&] {
+            auto each = [](VALUE key, VALUE value, VALUE arg) -> int {
+                auto &hash = *reinterpret_cast<T<K, V> *>(arg);
+                unprotect([&] {
+                    hash[RubyValue(key).to<K>()] = RubyValue(value).to<V>();
+                });
+                return ST_CONTINUE;
+            };
+            auto eachPtr = (int (*)(VALUE, VALUE, VALUE))each;
+            rb_hash_foreach(x, (int (*)(...))eachPtr, (VALUE)(&hash));
+        });
+        return hash;
+    }
+    static RubyValue to(const T<K, V> &hash)
+    {
+        RubyValue rubyHash = protect([&] {
+            return rb_hash_new();
+        });
+        for (auto i = hash.begin(); i != hash.end(); ++i) {
+            auto k = RubyValue::from(i.key());
+            auto v = RubyValue::from(i.value());
+            protect([&] {
+                rb_hash_aset(rubyHash, k, v);
+            });
+        }
+        return rubyHash;
+    }
+};
+
+// QObject-derived
+
+template <typename T>
+struct Conversion<
+    T *,
+    typename std::enable_if<
+        std::is_base_of<QObject, T>::value
+    >::type
+>
+{
+    static T *from(RubyValue value) { return dynamic_cast<T *>(value.toQObject()); }
+    static RubyValue to(T *value) { return RubyValue::fromQObject(value); }
+};
+
+template <>
+struct Conversion<const char *>
+{
+    static RubyValue to(const char *str);
+};
+
+} // namespace detail
+
+} // namespace RubyQml

data/ext/qml/signalforwarder.cpp

@@ -0,0 +1,66 @@
+#include "signalforwarder.h"
+#include "util.h"
+#include <QtCore/QDebug>
+
+namespace RubyQml {
+
+SignalForwarder::SignalForwarder(QObject *obj, const QMetaMethod &signal, RubyValue proc) :
+    QObject(obj),
+    mSignal(signal),
+    mProcRef(proc)
+{
+    QMetaObject::connect(obj, signal.methodIndex(), this, QObject::staticMetaObject.methodCount());
+}
+
+SignalForwarder::~SignalForwarder()
+{
+}
+
+int SignalForwarder::qt_metacall(QMetaObject::Call call, int id, void **args)
+{
+    id = QObject::qt_metacall(call, id, args);
+    if (id < 0) {
+        return id;
+    }
+    if (call == QMetaObject::InvokeMetaMethod) {
+        if (id == 0) {
+            forwardArgs(args);
+        }
+        --id;
+    }
+    return id;
+}
+
+void SignalForwarder::gc_mark()
+{
+    rb_gc_mark(mProcRef.value());
+}
+
+void SignalForwarder::forwardArgs(void **args)
+{
+    QVariantList list;
+    list.reserve(mSignal.parameterCount());
+    for (int i = 0; i < mSignal.parameterCount(); ++i) {
+        auto type = mSignal.parameterType(i);
+        if (type == QMetaType::QVariant) {
+            list << *static_cast<QVariant *>(args[i + 1]);
+        } else {
+            list << QVariant(type, args[i + 1]);
+        }
+    }
+    callProc(list);
+}
+
+void SignalForwarder::callProc(const QVariantList &list)
+{
+    if (mProcRef.hasValue()) {
+        withGvl([&] {
+            auto args = RubyValue::from(list);
+            protect([&] {
+                rb_funcall2(mProcRef.value(), rb_intern("call"), RARRAY_LEN(VALUE(args)), RARRAY_PTR(VALUE(args)));
+            });
+        });
+    }
+}
+
+} // namespace RubyQml

data/ext/qml/signalforwarder.h

@@ -0,0 +1,29 @@
+#pragma once
+#include "rubyvalue.h"
+#include "weakvaluereference.h"
+#include "markable.h"
+#include <QObject>
+#include <QMetaMethod>
+
+namespace RubyQml {
+
+class SignalForwarder : public QObject, public Markable
+{
+public:
+    SignalForwarder(QObject *obj, const QMetaMethod &signal, RubyValue proc);
+    ~SignalForwarder();
+
+    int qt_metacall(QMetaObject::Call call, int id, void **args) override;
+
+    void gc_mark() override;
+
+private:
+    void forwardArgs(void **args);
+    void callProc(const QVariantList &list);
+
+    QMetaMethod mSignal;
+    WeakValueReference mProcRef;
+};
+
+} // namespace RubyQml
+

data/ext/qml/util.cpp

@@ -0,0 +1,120 @@
+#include "util.h"
+#include "rubyvalue.h"
+#include <QString>
+#include <ruby/thread.h>
+#include <string>
+#include <memory>
+#include <cxxabi.h>
+
+namespace RubyQml {
+
+void protect(const std::function<void ()> &doAction)
+{
+    auto callback = [](VALUE data) {
+        auto &doAction= *reinterpret_cast<const std::function<void ()> *>(data);
+        doAction();
+        return Qnil;
+    };
+    int state;
+    rb_protect(callback, reinterpret_cast<VALUE>(&doAction), &state);
+    if (state) {
+        throw RubyException(state);
+    }
+}
+
+void unprotect(const std::function<void ()> &doAction) noexcept
+{
+    int state = 0;
+    bool cppErrorOccured= false;
+    VALUE cppErrorClassName = Qnil;
+    VALUE cppErrorMessage = Qnil;
+    try {
+        doAction();
+    }
+    catch (const RubyException &ex) {
+        state = ex.state();
+    }
+    catch (const std::exception &ex) {
+        cppErrorOccured = true;
+        int status;
+        auto classname = abi::__cxa_demangle(typeid(ex).name(), nullptr, nullptr, &status);
+        cppErrorClassName = rb_str_new_cstr(classname);
+        free(classname);
+        cppErrorMessage = rb_str_new_cstr(ex.what());
+    }
+    if (state) {
+        rb_jump_tag(state);
+    }
+    if (cppErrorOccured) {
+        auto patterns = rb_funcall(rb_path2class("QML::ErrorConverter"), rb_intern("patterns"), 0);
+        auto rubyClass = rb_hash_aref(patterns, cppErrorClassName);
+        VALUE exc;
+        if (RTEST(rubyClass)) {
+            exc = rb_funcall(rubyClass, rb_intern("new"), 1, cppErrorMessage);
+        } else {
+            exc = rb_funcall(rb_path2class("QML::CppError"), rb_intern("new"), 2, cppErrorClassName, cppErrorMessage);
+        }
+        rb_exc_raise(exc);
+    }
+}
+
+void rescue(const std::function<void ()> &doAction, const std::function<void (RubyValue)> &handleException)
+{
+    VALUE (*callback)(VALUE) = [](VALUE data) {
+        (*reinterpret_cast<std::function<void ()> *>(data))();
+        return Qnil;
+    };
+    VALUE (*rescueCallback)(VALUE, VALUE) = [](VALUE data, VALUE excObject) {
+        (*reinterpret_cast<std::function<void (VALUE)>*>(data))(excObject);
+        return Qnil;
+    };
+    rb_rescue((VALUE (*)(...))callback, (VALUE)&doAction, (VALUE (*)(...))rescueCallback, (VALUE)&handleException);
+}
+
+namespace {
+
+void changeGvl(const std::function<void ()> &doAction, bool gvl)
+{
+    auto actionPtr = const_cast<void *>(static_cast<const void *>(&doAction));
+    auto f = [](void *data) -> void * {
+        auto &doAction= *static_cast<const std::function<void ()> *>(data);
+        try {
+            doAction();
+        } catch (...) {
+            return new std::exception_ptr(std::current_exception());
+        }
+        return nullptr;
+    };
+    void *result;
+    if (gvl) {
+        result = rb_thread_call_with_gvl(f, actionPtr );
+    } else {
+        result = rb_thread_call_without_gvl(f, actionPtr , RUBY_UBF_IO, nullptr);
+    }
+    std::unique_ptr<std::exception_ptr> exc(static_cast<std::exception_ptr *>(result));
+    if (exc && *exc) {
+        std::rethrow_exception(*exc);
+    }
+}
+
+}
+
+void withoutGvl(const std::function<void ()> &doAction)
+{
+    changeGvl(doAction, false);
+}
+
+void withGvl(const std::function<void ()> &doAction)
+{
+    changeGvl(doAction, true);
+}
+
+void fail(const char *errorClassName, const QString &message)
+{
+    auto msg = message.toUtf8();
+    protect([&] {
+        rb_raise(rb_path2class(errorClassName), "%s", msg.data());
+    });
+}
+
+}