qml 0.0.7 → 1.0.0

data/ext/qml/rubyvalue.h

@@ -1,224 +0,0 @@
-#pragma once
-#include "util.h"
-#include <ruby.h>
-#include <array>
-
-class QVariant;
-class QJSValue;
-
-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
-    {
-        return rb_funcall(mValue, method, sizeof...(args), args...);
-    }
-
-    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 RubyValue &module) const
-    {
-        return RTEST(rb_obj_is_kind_of(mValue, module));
-    }
-
-    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 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 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)
-    {
-        auto type = rb_type(x);
-        if (type == T_FIXNUM || type == T_BIGNUM) {
-            return double(NUM2LL(x));
-        } else {
-            return RFLOAT_VALUE(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)
-    {
-        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)
-    {
-        auto ary = rb_ary_new();
-        for (const auto &elem : list) {
-            auto x = RubyValue::from(elem);
-            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)
-    {
-        x = rb_convert_type(x, T_HASH, "Hash", "to_hash");
-
-        T<K, V> hash;
-        auto each = [](VALUE key, VALUE value, VALUE arg) -> int {
-            auto &hash = *reinterpret_cast<T<K, V> *>(arg);
-            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)
-    {
-        auto rubyHash = rb_hash_new();
-        for (auto i = hash.begin(); i != hash.end(); ++i) {
-            auto k = RubyValue::from(i.key());
-            auto v = RubyValue::from(i.value());
-            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

@@ -1,64 +0,0 @@
-#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);
-            rb_apply(mProcRef.value(), RUBYQML_INTERN("call"), args);
-        });
-    }
-}
-
-} // namespace RubyQml

data/ext/qml/signalforwarder.h

@@ -1,29 +0,0 @@
-#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

@@ -1,112 +0,0 @@
-#include "util.h"
-#include "rubyvalue.h"
-#include <QString>
-#include <string>
-#include <memory>
-#include <cxxabi.h>
-
-#ifdef HAVE_RUBY_THREAD_H
-#include <ruby/thread.h>
-#else
-extern "C" {
-void *rb_thread_call_with_gvl(void *(*func)(void *), void *data1);
-void *rb_thread_call_without_gvl(void *(*func)(void *), void *data1, rb_unblock_function_t *ubf, void *data2);
-}
-#endif
-
-namespace RubyQml {
-
-void convertCppErrors(const std::function<void ()> &doAction) noexcept
-{
-    bool cppErrorOccured= false;
-    VALUE cppErrorClassName = Qnil;
-    VALUE cppErrorMessage = Qnil;
-    try {
-        doAction();
-    }
-    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 (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);
-}
-
-void rescueNotify(const std::function<void ()> &doAction)
-{
-    rescue(doAction, [&](RubyValue excObject) {
-        rb_funcall(rb_path2class("QML::Application"), rb_intern("notify_error"), 1, excObject);
-    });
-}
-
-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();
-    rb_raise(rb_path2class(errorClassName), "%s", msg.data());
-}
-
-}

data/ext/qml/util.h

@@ -1,82 +0,0 @@
-#pragma once
-
-#include <QMetaType>
-#include <functional>
-#include <type_traits>
-#include <array>
-#include <ruby.h>
-
-#ifndef RARRAY_AREF
-#define RARRAY_AREF(a, i)    ((RARRAY_PTR(a)[i]))
-#endif
-
-namespace RubyQml {
-
-template <size_t... Indices>
-struct IntegerSequence {};
-
-template <size_t N, typename Seq = IntegerSequence<>, bool Last = N == 0>
-struct MakeIntegerSequenceImpl
-{
-    using type = Seq;
-};
-
-template <size_t N, size_t... Indices>
-struct MakeIntegerSequenceImpl<N, IntegerSequence<Indices...>, false> :
-        MakeIntegerSequenceImpl<N - 1, IntegerSequence<N - 1, Indices...>>
-{};
-
-template <size_t N>
-using MakeIntegerSequence = typename MakeIntegerSequenceImpl<N>::type;
-
-template <typename F, typename... Args, size_t... Indices>
-typename std::result_of<F(Args...)>::type
-applyWithTupleImpl(const F &func, const std::tuple<Args...> &args, IntegerSequence<Indices...>)
-{
-    return func(std::get<Indices>(args)...);
-}
-
-template <typename F, typename... Args>
-typename std::result_of<F(Args...)>::type
-applyWithTuple(const F &func, const std::tuple<Args...> &args)
-{
-    return applyWithTupleImpl(func, args, MakeIntegerSequence<sizeof...(Args)>());
-}
-
-class RubyValue;
-
-class RubyException
-{
-public:
-    RubyException(int state) : mState(state) {}
-    int state() const { return mState; }
-private:
-    int mState = 0;
-};
-
-void convertCppErrors(const std::function<void()> &doAction) noexcept;
-
-void rescue(const std::function<void ()> &doAction, const std::function<void (RubyValue)> &handleException);
-void rescueNotify(const std::function<void ()> &doAction);
-
-// call function with GVL unlocked
-void withoutGvl(const std::function<void()> &doAction);
-
-// call function with GVL locked
-void withGvl(const std::function<void()> &doAction);
-
-void fail(const char *errorClassName, const QString &message);
-
-template <typename ... TArgs>
-void callSuper(TArgs ... args)
-{
-    constexpr int argc = sizeof...(args);
-    std::array<VALUE, argc> argv = {{ VALUE(args)... }};
-    protect([&] {
-        rb_call_super(argc, argv.data());
-    });
-}
-
-} // namespace RubyQml
-
-Q_DECLARE_METATYPE(const QMetaObject*)