qml 0.0.1

data/ext/qml/plugins/testutil/testutilplugin.h

@@ -0,0 +1,32 @@
+#pragma once
+#include <QObject>
+#include <QVariant>
+
+namespace RubyQml {
+
+class TestObject;
+class TestObjectSubclass;
+class OwnershipTest;
+class ObjectLifeChecker;
+
+class TestUtilPlugin : public QObject
+{
+    Q_OBJECT
+    Q_PLUGIN_METADATA(IID "org.ruby-qml.RubyQml.TestObject")
+public:
+    explicit TestUtilPlugin(QObject *parent = 0);
+signals:
+
+public slots:
+    QVariantHash metaObjects() { return mMetaObjects; }
+
+    RubyQml::TestObject *createTestObject();
+    RubyQml::TestObjectSubclass *createTestObjectSubclass();
+    RubyQml::OwnershipTest *createOwnershipTest();
+    RubyQml::ObjectLifeChecker *createObjectLifeChecker(QObject *target);
+
+private:
+    QVariantHash mMetaObjects;
+};
+
+} // namespace RubyQml

data/ext/qml/qmltyperegisterer.cpp

@@ -0,0 +1,74 @@
+#include "qmltyperegisterer.h"
+#include "foreignmetaobject.h"
+#include "accessobject.h"
+#include <QtQml>
+
+namespace RubyQml {
+
+QmlTypeRegisterer::QmlTypeRegisterer(const SP<ForeignMetaObject> &metaObject, const std::function<void (void *)> &createFunc) :
+    mMetaObject(metaObject),
+    mCreateFunc(createFunc)
+{
+    mFactoryArgs[0] = &ffi_type_pointer;
+    if (ffi_prep_cif(&mFactoryCif, FFI_DEFAULT_ABI, 1, &ffi_type_void, mFactoryArgs) != FFI_OK) {
+        throw std::runtime_error("failed to prepare FFI call interface");
+    }
+    mFactoryClosure = (ffi_closure *)ffi_closure_alloc(sizeof(ffi_closure), (void **)(&mFactoryFunc));
+    if (!mFactoryClosure) {
+        throw std::runtime_error("failed to allocate FFI closure");
+    }
+
+    auto callback = [](ffi_cif *cif, void *ret, void **args, void *data) {
+        Q_UNUSED(cif);
+        Q_UNUSED(ret);
+        auto self = (QmlTypeRegisterer *)(data);
+        self->mCreateFunc(*(void **)(args[0]));
+    };
+
+    if (ffi_prep_closure_loc(mFactoryClosure, &mFactoryCif, callback, this, (void *)mFactoryFunc) != FFI_OK) {
+        ffi_closure_free(mFactoryClosure);
+        throw std::runtime_error("failed to prepare FFI closure");
+    }
+}
+
+QmlTypeRegisterer::~QmlTypeRegisterer()
+{
+    ffi_closure_free(mFactoryClosure);
+}
+
+void QmlTypeRegisterer::registerType(const char *uri, int versionMajor, int versionMinor, const char *qmlName)
+{
+    QByteArray className;
+    className += mMetaObject->className();
+    className += "*";
+
+    QByteArray listName;
+    listName += "QQmlListProperty<";
+    listName += mMetaObject->className();
+    listName += ">";
+
+    QQmlPrivate::RegisterType type = {
+        0,
+        qRegisterNormalizedMetaType<AccessWrapper *>(className),
+        qRegisterNormalizedMetaType<QQmlListProperty<AccessWrapper> >(listName),
+        sizeof(AccessWrapper), mFactoryFunc,
+        QString(),
+
+        uri, versionMajor, versionMinor, qmlName, mMetaObject.get(),
+
+        0, 0,
+
+        QQmlPrivate::StaticCastSelector<AccessWrapper,QQmlParserStatus>::cast(),
+        QQmlPrivate::StaticCastSelector<AccessWrapper,QQmlPropertyValueSource>::cast(),
+        QQmlPrivate::StaticCastSelector<AccessWrapper,QQmlPropertyValueInterceptor>::cast(),
+
+        0, 0,
+
+        0,
+        0
+    };
+
+    QQmlPrivate::qmlregister(QQmlPrivate::TypeRegistration, &type);
+}
+
+} // namespace RubyQml

data/ext/qml/qmltyperegisterer.h

@@ -0,0 +1,30 @@
+#pragma once
+#include "common.h"
+#include <ffi.h>
+#include <functional>
+
+namespace RubyQml {
+
+class ForeignMetaObject;
+
+class QmlTypeRegisterer
+{
+public:
+    using FactoryFunction = void (*)(void *);
+
+    QmlTypeRegisterer(const SP<ForeignMetaObject> &metaObject, const std::function<void(void *)> &createFunc);
+    ~QmlTypeRegisterer();
+
+    void registerType(const char *uri, int versionMajor, int versionMinor, const char *qmlName);
+
+private:
+
+    SP<ForeignMetaObject> mMetaObject;
+    std::function<void (void *)> mCreateFunc;
+    ffi_type *mFactoryArgs[1];
+    ffi_cif mFactoryCif;
+    ffi_closure *mFactoryClosure = nullptr;
+    FactoryFunction mFactoryFunc = nullptr;
+};
+
+} // namespace RubyQml

data/ext/qml/rubyclass.cpp

@@ -0,0 +1,94 @@
+#include "rubyclass.h"
+
+namespace RubyQml {
+
+RubyModule::RubyModule(VALUE moduleValue) :
+    RubyModule(RubyValue(moduleValue))
+{
+}
+
+RubyModule::RubyModule(RubyValue moduleValue) :
+    mValue(moduleValue)
+{
+    checkType();
+}
+
+RubyModule::RubyModule(const char *name)
+{
+    protect([&] {
+        mValue = rb_define_module(name);
+    });
+}
+
+RubyModule::RubyModule(const RubyModule &under, const char *name)
+{
+    protect([&] {
+        mValue = rb_define_module_under(under.toValue(), name);
+    });
+}
+
+RubyModule &RubyModule::operator=(const RubyModule &other)
+{
+    mValue = other.mValue;
+    checkType();
+    return *this;
+}
+
+RubyModule RubyModule::fromPath(const char *path)
+{
+    RubyValue ret;
+    protect([&] {
+        ret = rb_path2class(path);
+    });
+    return ret;
+}
+
+void RubyModule::aliasMethod(const char *newName, const char *originalName)
+{
+    protect([&] {
+        rb_alias(mValue, rb_intern(newName), rb_intern(originalName));
+    });
+}
+
+void RubyModule::checkType()
+{
+    if (!protect([&] { return rb_obj_is_kind_of(mValue, rb_cModule); })) {
+        throw std::logic_error("expected Module value");
+    }
+}
+
+RubyClass::RubyClass(RubyValue classValue) :
+    RubyModule(classValue)
+{
+    checkType();
+}
+
+namespace {
+
+RubyValue defineClass(const RubyModule &under, const char *name)
+{
+    return protect([&] {
+        return rb_define_class_under(under.toValue(), name, rb_cObject);
+    });
+}
+
+}
+
+RubyClass::RubyClass(const RubyModule &under, const char *name) :
+    RubyModule(defineClass(under, name))
+{
+}
+
+RubyClass RubyClass::fromPath(const char *path)
+{
+    return RubyClass(RubyModule::fromPath(path).toValue());
+}
+
+void RubyClass::checkType()
+{
+    if (!toValue().isKindOf(rb_cClass)) {
+        throw std::logic_error("expected Class value");
+    }
+}
+
+} // namespace RubyQml

data/ext/qml/rubyclass.h

@@ -0,0 +1,234 @@
+#pragma once
+#include "functioninfo.h"
+#include "rubyvalue.h"
+#include <QDebug>
+#include <memory>
+
+namespace RubyQml {
+
+enum class MethodAccess { Public, Protected, Private };
+enum class MethodType { InstanceMethod, ModuleFunction };
+
+class RubyModule
+{
+public:
+    RubyModule() = default;
+    RubyModule(VALUE moduleValue);
+    RubyModule(RubyValue moduleValue);
+    RubyModule(const char *name);
+    RubyModule(const RubyModule &under, const char *name);
+    RubyModule(const RubyModule &) = default;
+    RubyModule(RubyModule &&) = default;
+    RubyModule &operator=(const RubyModule &other);
+
+    static RubyModule fromPath(const char *path);
+
+    template <typename TFunction, TFunction function>
+    void defineMethod(MethodType type, MethodAccess access, const char *name, FunctionInfo<TFunction, function>)
+    {
+        using wrapper = FunctionWrapper<TFunction, function>;
+        auto func = (VALUE (*)(...))wrapper::apply;
+        auto argc = wrapper::argc - 1;
+
+        protect([&] {
+            switch (type) {
+            case MethodType::InstanceMethod:
+                switch (access) {
+                case MethodAccess::Public:
+                    rb_define_method(mValue , name, func, argc);
+                    break;
+                case MethodAccess::Protected:
+                    rb_define_protected_method(mValue, name, func, argc);
+                    break;
+                case MethodAccess::Private:
+                    rb_define_private_method(mValue, name, func, argc);
+                    break;
+                }
+                break;
+            case MethodType::ModuleFunction:
+                rb_define_module_function(mValue, name, func, argc);
+                break;
+            }
+        });
+    }
+
+    template <typename T>
+    void defineMethod(MethodAccess access, const char *name, T info)
+    {
+        defineMethod(MethodType::InstanceMethod, access, name, info);
+    }
+
+    template <typename T>
+    void defineModuleFunction(const char *name, T info)
+    {
+        defineMethod(MethodType::ModuleFunction, MethodAccess::Public, name, info);
+    }
+
+    template <typename T>
+    void defineMethod(const char *name, T info)
+    {
+        defineMethod(MethodAccess::Public, name, info);
+    }
+
+    void aliasMethod(const char *newName, const char *originalName);
+
+    RubyValue toValue() const { return mValue; }
+    operator RubyValue() const { return toValue(); }
+    operator VALUE() const { return toValue(); }
+
+    virtual void checkType();
+
+private:
+    template <typename TFunction, TFunction function>
+    struct FunctionWrapper;
+
+    template <typename ... TArgs, RubyValue (*function)(TArgs...)>
+    struct FunctionWrapper<RubyValue (*)(TArgs...), function>
+    {
+        static constexpr size_t argc = sizeof...(TArgs);
+
+        static VALUE apply(typename std::conditional<true, VALUE, TArgs>::type... args)
+        {
+            RubyValue ret;
+            // use tuple to avoid gcc 4.8's bug (https://gcc.gnu.org/bugzilla/show_bug.cgi?id=55914)
+            auto tuple = std::make_tuple(args...);
+            unprotect([&] {
+                ret = applyWithTuple(function, tuple);
+            });
+            return ret;
+        }
+    };
+
+    RubyValue mValue;
+};
+
+class RubyClass : public RubyModule
+{
+public:
+    RubyClass() = default;
+    RubyClass(RubyValue classValue);
+    RubyClass(const RubyModule &under, const char *name);
+
+    static RubyClass fromPath(const char *path);
+
+    void checkType() override;
+
+    template <typename ... Args>
+    RubyValue newInstance(Args ... args)
+    {
+        return toValue().send(RUBYQML_INTERN("new"), args...);
+    }
+};
+
+
+template <typename T>
+class WrapperRubyClass : public RubyClass
+{
+public:
+    WrapperRubyClass(const RubyModule &under, const char *name) :
+        RubyClass(under, name)
+    {
+        if (mInstance) {
+            throw std::logic_error("class already defined");
+        }
+        mInstance.reset(new WrapperRubyClass(*this));
+
+        protect([&] {
+            rb_define_alloc_func(toValue(), &alloc);
+        });
+    }
+
+    T *unwrap(RubyValue value)
+    {
+        auto klass = this->toValue();
+        protect([&] {
+            if (!RTEST(rb_obj_is_kind_of(value, klass))) {
+                rb_raise(rb_eTypeError, "expected %s, got %s", rb_class2name(klass), rb_obj_classname(value));
+            }
+        });
+        T *ptr;
+        Data_Get_Struct(VALUE(value), T, ptr);
+        return ptr;
+    }
+
+    using RubyClass::defineMethod;
+
+    template <typename TMemberFunction, TMemberFunction memberFunction>
+    void defineMethod(MethodAccess access, const char *name, MemberFunctionInfo<TMemberFunction, memberFunction>)
+    {
+        using wrapper = MethodWrapper<TMemberFunction, memberFunction>;
+        defineMethod(access, name, RUBYQML_FUNCTION_INFO(&wrapper::apply));
+    }
+
+    template <typename TMemberFunction, TMemberFunction memberFunction>
+    void defineMethod(const char *name, MemberFunctionInfo<TMemberFunction, memberFunction> info)
+    {
+        defineMethod(MethodAccess::Public, name, info);
+    }
+
+    static WrapperRubyClass instance()
+    {
+        if (!mInstance) {
+            throw std::logic_error("class not yet defined");
+        }
+        return *mInstance;
+    }
+
+private:
+
+    template <typename TMemberFunction, TMemberFunction memfn>
+    struct MethodWrapper;
+
+    template <typename ... TArgs, RubyValue (T::*memfn)(TArgs ...)>
+    struct MethodWrapper<RubyValue (T::*)(TArgs ...), memfn>
+    {
+        static RubyValue apply(RubyValue self, TArgs ... args)
+        {
+            return (instance().unwrap(self)->*memfn)(args ...);
+        }
+    };
+
+    template <typename ... TArgs, RubyValue (T::*memfn)(TArgs ...) const>
+    struct MethodWrapper<RubyValue (T::*)(TArgs ...) const, memfn>
+    {
+        static RubyValue apply(RubyValue self, TArgs... args)
+        {
+            return (instance().unwrap(self)->*memfn)(args ...);
+        }
+    };
+
+    static void mark(T *ptr) noexcept
+    {
+        ptr->gc_mark();
+    }
+
+    static void dealloc(T *ptr) noexcept
+    {
+        withoutGvl([&] {
+            ptr->~T();
+        });
+        ruby_xfree(ptr);
+    }
+
+    static VALUE alloc(VALUE klass) noexcept
+    {
+        auto ptr = ruby_xmalloc(sizeof(T));
+        auto self = Data_Wrap_Struct(klass, &mark, &dealloc, ptr);
+        new(ptr) T(self);
+        return self;
+    }
+
+    static std::unique_ptr<WrapperRubyClass> mInstance;
+};
+
+template <typename T>
+std::unique_ptr<WrapperRubyClass<T>> WrapperRubyClass<T>::mInstance = nullptr;
+
+template <typename T>
+inline WrapperRubyClass<T> wrapperRubyClass()
+{
+    return WrapperRubyClass<T>::instance();
+}
+
+} // namespace RubyQml
+