qml 0.0.7 → 1.0.0

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

@@ -1,55 +0,0 @@
-#include "testutilplugin.h"
-#include "testobject.h"
-#include "testobjectsubclass.h"
-#include "ownershiptest.h"
-#include "objectlifechecker.h"
-#include "imageprovidertest.h"
-#include <QtQml>
-#include <QQuickWindow>
-
-Q_DECLARE_METATYPE(const QMetaObject*)
-
-namespace RubyQml {
-
-TestUtilPlugin::TestUtilPlugin(QObject *parent) :
-    QObject(parent)
-{
-    qRegisterMetaType<TestObject *>();
-    qRegisterMetaType<TestObject::Enums>();
-    qRegisterMetaType<TestObjectSubclass *>();
-    qRegisterMetaType<OwnershipTest *>();
-    qRegisterMetaType<ObjectLifeChecker *>();
-    qRegisterMetaType<ImageProviderTest *>();
-
-    auto metaObjects = { &TestObject::staticMetaObject, &ObjectLifeChecker::staticMetaObject};
-    for (auto metaobj : metaObjects) {
-        mMetaObjects[metaobj->className()] = QVariant::fromValue(metaobj);
-    }
-}
-
-TestObject *TestUtilPlugin::createTestObject()
-{
-    return new TestObject();
-}
-
-TestObjectSubclass *TestUtilPlugin::createTestObjectSubclass()
-{
-    return new TestObjectSubclass();
-}
-
-OwnershipTest *TestUtilPlugin::createOwnershipTest()
-{
-    return new OwnershipTest();
-}
-
-ObjectLifeChecker *TestUtilPlugin::createObjectLifeChecker(QObject *target)
-{
-    return new ObjectLifeChecker(target);
-}
-
-ImageProviderTest *TestUtilPlugin::createImageProviderTest()
-{
-    return new ImageProviderTest();
-}
-
-} // namespace RubyQml

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

@@ -1,36 +0,0 @@
-#pragma once
-#include <QObject>
-#include <QVariant>
-
-class QQuickWindow;
-
-namespace RubyQml {
-
-class TestObject;
-class TestObjectSubclass;
-class OwnershipTest;
-class ObjectLifeChecker;
-class ImageProviderTest;
-
-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);
-    RubyQml::ImageProviderTest *createImageProviderTest();
-
-private:
-    QVariantHash mMetaObjects;
-};
-
-} // namespace RubyQml

data/ext/qml/qmltyperegisterer.cpp

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

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

@@ -1,82 +0,0 @@
-#include "rubyclass.h"
-
-namespace RubyQml {
-
-RubyModule::RubyModule(VALUE moduleValue) :
-    RubyModule(RubyValue(moduleValue))
-{
-}
-
-RubyModule::RubyModule(RubyValue moduleValue) :
-    mValue(moduleValue)
-{
-    checkType();
-}
-
-RubyModule::RubyModule(const char *name)
-{
-    mValue = rb_define_module(name);
-}
-
-RubyModule::RubyModule(const RubyModule &under, const char *name)
-{
-    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)
-{
-    return rb_path2class(path);
-}
-
-void RubyModule::aliasMethod(const char *newName, const char *originalName)
-{
-    rb_alias(mValue, rb_intern(newName), rb_intern(originalName));
-}
-
-void RubyModule::checkType()
-{
-    if (!mValue.isKindOf(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 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

@@ -1,230 +0,0 @@
-#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;
-
-        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...);
-            convertCppErrors([&] {
-                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));
-
-        rb_define_alloc_func(toValue(), &alloc);
-    }
-
-    T *unwrap(RubyValue value)
-    {
-        auto klass = this->toValue();
-
-        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
-