qml 0.0.1

data/ext/qml/accessclass.h

@@ -0,0 +1,19 @@
+#pragma once
+#include "foreignclass.h"
+#include "rubyvalue.h"
+
+namespace RubyQml {
+
+class AccessWrapper;
+
+class AccessClass : public ForeignClass
+{
+public:
+    AccessClass(RubyValue className, RubyValue methodInfos, RubyValue signalInfos, RubyValue propertyInfos);
+
+    QVariant callMethod(ForeignObject *obj, size_t id, const QVariantList &args) override;
+    void setProperty(ForeignObject *obj, size_t id, const QVariant &value) override;
+    QVariant getProperty(ForeignObject *obj, size_t id) override;
+};
+
+} // namespace RubyQml

data/ext/qml/accessobject.cpp

@@ -0,0 +1,30 @@
+#include "accessobject.h"
+#include "util.h"
+#include "rubyclass.h"
+#include <QSet>
+
+namespace RubyQml {
+
+AccessWrapper::AccessWrapper(const SP<ForeignMetaObject> &metaobj, RubyValue value) :
+    ForeignObject(metaobj),
+    mWrapped(value)
+{
+    if (!value.isKindOf(RubyModule::fromPath("QML::Access"))) {
+        std::logic_error("wrapping non QML::Access object");
+    }
+    value.send("access_wrappers").send("push", RubyValue::fromQObject(this, false));
+}
+
+AccessWrapper::~AccessWrapper()
+{
+    if (mWrapped.hasValue()) {
+        mWrapped.value().send("access_wrappers").send("delete", RubyValue::fromQObject(this, false));
+    }
+}
+
+void AccessWrapper::gc_mark()
+{
+    rb_gc_mark(mWrapped.value());
+}
+
+} // namespace RubyQml

data/ext/qml/accessobject.h

@@ -0,0 +1,22 @@
+#pragma once
+#include "weakvaluereference.h"
+#include "foreignobject.h"
+#include "markable.h"
+
+namespace RubyQml {
+
+class AccessWrapper : public ForeignObject, public Markable
+{
+public:
+    AccessWrapper(const SP<ForeignMetaObject> &metaobj, RubyValue wrappedValue);
+    ~AccessWrapper();
+
+    RubyValue wrappedValue() { return mWrapped.value(); }
+    void gc_mark() override;
+
+private:
+    WeakValueReference mWrapped;
+};
+
+} // namespace RubyQml
+

data/ext/qml/application.cpp

@@ -0,0 +1,54 @@
+#include "application.h"
+#include "util.h"
+
+namespace RubyQml {
+namespace Application {
+
+namespace {
+
+int argc;
+QList<QByteArray> argData;
+char **argv;
+
+QApplication *application_;
+QQmlEngine *engine_;
+
+}
+
+void failIfUninitialized()
+{
+    if (!initialized()) {
+        fail("QML::UninitializedError", "ruby-qml not yet initialized");
+    }
+}
+
+QApplication *application()
+{
+    failIfUninitialized();
+    return application_;
+}
+
+QQmlEngine *engine()
+{
+    failIfUninitialized();
+    return engine_;
+}
+
+bool initialized()
+{
+    return application_;
+}
+
+void init(const QList<QByteArray> &args)
+{
+    argc = args.size();
+    argData = args;
+    argv = new char*[argc];
+    std::transform(argData.begin(), argData.end(), argv, [](QByteArray &ba) { return ba.data(); });
+
+    application_ = new QApplication(argc, argv);
+    engine_ = new QQmlEngine();
+}
+
+}
+} // namespace RubyQml

data/ext/qml/application.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#include <QList>
+#include <QApplication>
+#include <QQmlEngine>
+
+namespace RubyQml {
+namespace Application {
+
+QApplication *application();
+QQmlEngine *engine();
+bool initialized();
+
+void init(const QList<QByteArray> &args);
+
+}
+} // namespace RubyQml

data/ext/qml/common.h

@@ -0,0 +1,18 @@
+#pragma once
+#include <memory>
+
+namespace RubyQml {
+
+template <typename T>
+using SP = std::shared_ptr<T>;
+
+template <typename T>
+using WP = std::weak_ptr<T>;
+
+template <typename T, typename ... Args>
+inline SP<T> makeSP(Args && ... args)
+{
+    return std::make_shared<T>(std::forward<Args>(args)...);
+}
+
+} // namespace RubyQml

data/ext/qml/ext_accesssupport.cpp

@@ -0,0 +1,77 @@
+#include "ext_accesssupport.h"
+#include "ext_pointer.h"
+#include "rubyclass.h"
+#include "accessclass.h"
+#include "accessobject.h"
+#include "foreignmetaobject.h"
+#include "qmltyperegisterer.h"
+
+namespace RubyQml {
+namespace Ext {
+
+AccessWrapperFactory::AccessWrapperFactory(RubyValue self) :
+    self(self)
+{
+}
+
+AccessWrapperFactory::~AccessWrapperFactory()
+{
+}
+
+RubyValue AccessWrapperFactory::ext_initialize(RubyValue rubyClass, RubyValue className, RubyValue methodInfos, RubyValue signalInfos, RubyValue propertyInfos)
+{
+    mRubyClass = rubyClass;
+    mAccessClass = makeSP<AccessClass>(className, methodInfos, signalInfos, propertyInfos);
+    mMetaObject = makeSP<ForeignMetaObject>(mAccessClass);
+    return self;
+}
+
+RubyValue AccessWrapperFactory::ext_emitSignal(RubyValue obj, RubyValue name, RubyValue args)
+{
+    auto accessObj = wrapperRubyClass<Pointer>().unwrap(obj.send("access_object"))->fetchQObject();
+    auto nameId = name.toID();
+    auto argVariants = args.to<QVariantList>();
+    withoutGvl([&] {
+        mMetaObject->emitSignal(dynamic_cast<ForeignObject *>(accessObj), nameId, argVariants);
+    });
+    return Qnil;
+}
+
+RubyValue AccessWrapperFactory::ext_registerToQml(RubyValue path, RubyValue majorVersion, RubyValue minorVersion, RubyValue name)
+{
+    using namespace std::placeholders;
+    if (!mTypeRegisterer) {
+        mTypeRegisterer = makeSP<QmlTypeRegisterer>(mMetaObject, std::bind(&AccessWrapperFactory::newInstanceInto, this, _1));
+        mTypeRegisterer->registerType(path.to<QByteArray>(), majorVersion.to<int>(), minorVersion.to<int>(), name.to<QByteArray>());
+    }
+    return self;
+}
+
+RubyValue AccessWrapperFactory::ext_create(RubyValue access)
+{
+    return RubyValue::fromQObject(create(access), false);
+}
+
+AccessWrapper *AccessWrapperFactory::create(RubyValue access)
+{
+    return new AccessWrapper(mMetaObject, access);
+}
+
+void AccessWrapperFactory::newInstanceInto(void *where)
+{
+    withGvl([&] {
+        new(where) AccessWrapper(mMetaObject, mRubyClass.send("new"));
+    });
+}
+
+void AccessWrapperFactory::defineClass()
+{
+    WrapperRubyClass<AccessWrapperFactory> klass(RubyModule::fromPath("QML"), "AccessWrapperFactory");
+    klass.defineMethod(MethodAccess::Protected, "initialize", RUBYQML_MEMBER_FUNCTION_INFO(&AccessWrapperFactory::ext_initialize));
+    klass.defineMethod("emit_signal", RUBYQML_MEMBER_FUNCTION_INFO(&AccessWrapperFactory::ext_emitSignal));
+    klass.defineMethod("register_to_qml", RUBYQML_MEMBER_FUNCTION_INFO(&AccessWrapperFactory::ext_registerToQml));
+    klass.defineMethod("create", RUBYQML_MEMBER_FUNCTION_INFO(&AccessWrapperFactory::ext_create));
+}
+
+} // namespace Ext
+} // namespace RubyQml

data/ext/qml/ext_accesssupport.h

@@ -0,0 +1,42 @@
+#pragma once
+#include "common.h"
+#include "rubyvalue.h"
+
+namespace RubyQml {
+
+class AccessClass;
+class ForeignMetaObject;
+class QmlTypeRegisterer;
+class AccessWrapper;
+
+namespace Ext {
+
+class AccessWrapperFactory
+{
+public:
+    AccessWrapperFactory(RubyValue self);
+    ~AccessWrapperFactory();
+
+    RubyValue ext_initialize(RubyValue rubyClass, RubyValue className, RubyValue methodInfos, RubyValue signalInfos, RubyValue propertyInfos);
+    RubyValue ext_emitSignal(RubyValue obj, RubyValue name, RubyValue args);
+    RubyValue ext_registerToQml(RubyValue path, RubyValue majorVersion, RubyValue minorVersion, RubyValue name);
+    RubyValue ext_create(RubyValue access);
+
+    AccessWrapper *create(RubyValue access);
+
+    void gc_mark() {}
+    static void defineClass();
+
+private:
+
+    void newInstanceInto(void *where);
+
+    const RubyValue self;
+    RubyValue mRubyClass;
+    SP<AccessClass> mAccessClass;
+    SP<ForeignMetaObject> mMetaObject;
+    SP<QmlTypeRegisterer> mTypeRegisterer;
+};
+
+} // namespace Ext
+} // namespace RubyQml

data/ext/qml/ext_gcmarker.cpp

@@ -0,0 +1,39 @@
+#include "ext_gcmarker.h"
+#include "rubyclass.h"
+#include <QtCore/QSet>
+
+namespace RubyQml {
+namespace Ext {
+
+GCMarker::GCMarker(RubyValue self)
+{
+    Q_UNUSED(self)
+}
+
+RubyValue GCMarker::fromMarkFunction(const std::function<void ()> &func)
+{
+    auto klass = wrapperRubyClass<GCMarker>();
+    auto marker = klass.newInstance();
+    klass.unwrap(marker)->setMarkFunction(func);
+    return marker;
+}
+
+void GCMarker::setMarkFunction(const std::function<void ()> &func)
+{
+    mMarkFunc = func;
+}
+
+void GCMarker::gc_mark()
+{
+    if (mMarkFunc)
+        mMarkFunc();
+}
+
+void GCMarker::defineClass()
+{
+    WrapperRubyClass<GCMarker> klass(RubyModule::fromPath("QML"), "GCProtection");
+    Q_UNUSED(klass);
+}
+
+} // namespace Ext
+} // namespace RubyQml

data/ext/qml/ext_gcmarker.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include "rubyvalue.h"
+#include <functional>
+
+namespace RubyQml {
+
+namespace Ext {
+
+class GCMarker
+{
+public:
+    GCMarker(RubyValue self);
+    static RubyValue fromMarkFunction(const std::function<void ()> &func);
+
+    void setMarkFunction(const std::function<void()> &func);
+    void gc_mark();
+
+    static void defineClass();
+
+private:
+    std::function<void ()> mMarkFunc;
+};
+
+} // namespace Ext
+
+} // namespace RubyQml

data/ext/qml/ext_kernel.cpp

@@ -0,0 +1,62 @@
+#include "ext_kernel.h"
+#include "application.h"
+#include "rubyvalue.h"
+#include "rubyclass.h"
+
+namespace RubyQml {
+namespace Ext {
+namespace Kernel {
+
+namespace {
+
+RubyValue application(RubyValue self)
+{
+    Q_UNUSED(self);
+    return RubyValue::from(Application::application());
+}
+
+RubyValue engine(RubyValue self)
+{
+    Q_UNUSED(self);
+    return RubyValue::from(Application::engine());
+}
+
+RubyValue applicationMetaObject()
+{
+    return RubyValue::from(&QApplication::staticMetaObject);
+}
+
+RubyValue engineMetaObject()
+{
+    return RubyValue::from(&QQmlEngine::staticMetaObject);
+}
+
+RubyValue init(RubyValue self, RubyValue argv)
+{
+    Q_UNUSED(self);
+    Application::init(argv.to<QList<QByteArray>>());
+    return Qnil;
+}
+
+RubyValue initialized(RubyValue self)
+{
+    Q_UNUSED(self);
+    return RubyValue::from(Application::initialized());
+}
+
+}
+
+void defineModule()
+{
+    RubyModule kernel(RubyModule::fromPath("QML"), "Kernel");
+    kernel.defineModuleFunction("application", RUBYQML_FUNCTION_INFO(&application));
+    kernel.defineModuleFunction("engine", RUBYQML_FUNCTION_INFO(&engine));
+    kernel.defineModuleFunction("application_meta_object", RUBYQML_FUNCTION_INFO(&applicationMetaObject));
+    kernel.defineModuleFunction("engine_meta_object", RUBYQML_FUNCTION_INFO(&engineMetaObject));
+    kernel.defineModuleFunction("init", RUBYQML_FUNCTION_INFO(&init));
+    kernel.defineModuleFunction("initialized?", RUBYQML_FUNCTION_INFO(&initialized));
+}
+
+} // namespace Kernel
+} // namespace Ext
+} // namespace RubyQml

data/ext/qml/ext_kernel.h

@@ -0,0 +1,11 @@
+#pragma once
+
+namespace RubyQml {
+namespace Ext {
+namespace Kernel {
+
+void defineModule();
+
+} // namespace Kernel
+} // namespace Ext
+} // namespace RubyQml

data/ext/qml/ext_metaobject.cpp

@@ -0,0 +1,410 @@
+#include "ext_metaobject.h"
+#include "util.h"
+#include "ext_pointer.h"
+#include "rubyclass.h"
+#include "signalforwarder.h"
+#include <QtCore/QMetaObject>
+#include <QtCore/QMetaMethod>
+#include <QtCore/QMetaProperty>
+#include <QtCore/QMetaEnum>
+#include <QtCore/QVariant>
+#include <array>
+#include <QtCore/QDebug>
+#include <QtQml/QQmlEngine>
+
+namespace RubyQml {
+namespace Ext {
+
+namespace {
+
+RubyValue idListToArray(const QList<ID> &xs)
+{
+    return protect([&] {
+        auto ary = rb_ary_new();
+        for (ID id : xs) {
+            rb_ary_push(ary, ID2SYM(id));
+        }
+        return ary;
+    });
+}
+
+}
+
+MetaObject::MetaObject(RubyValue self) :
+    self(self)
+{
+    setMetaObject(&QObject::staticMetaObject);
+}
+
+RubyValue MetaObject::className() const
+{
+    return rb_str_new_cstr(mMetaObject->className());
+}
+
+RubyValue MetaObject::methodNames() const
+{
+    return idListToArray(mMethodHash.keys());
+}
+
+RubyValue MetaObject::isPublic(RubyValue name) const
+{
+    auto methods = findMethods(name);
+    return RubyValue::from(mMetaObject->method(methods.first()).access() == QMetaMethod::Public);
+}
+RubyValue MetaObject::isProtected(RubyValue name) const
+{
+    auto methods = findMethods(name);
+    return RubyValue::from(mMetaObject->method(methods.first()).access() == QMetaMethod::Protected);
+}
+RubyValue MetaObject::isPrivate(RubyValue name) const
+{
+    auto methods = findMethods(name);
+    return RubyValue::from(mMetaObject->method(methods.first()).access() == QMetaMethod::Private);
+}
+RubyValue MetaObject::isSignal(RubyValue name) const
+{
+    auto methods = findMethods(name);
+    return RubyValue::from(mMetaObject->method(methods.first()).methodType() == QMetaMethod::Signal);
+}
+
+class MethodInvoker
+{
+public:
+    MethodInvoker(RubyValue args, const QMetaMethod &method) :
+        mArgs(args), mMethod(method) {}
+
+    bool isArgsCompatible() const
+    {
+        int count = RARRAY_LEN(VALUE(mArgs));
+        if (mMethod.parameterCount() != count) {
+            return false;
+        }
+        for (int i = 0; i < count; ++i) {
+            auto metaType = mMethod.parameterType(i);
+            RubyValue arg = RARRAY_AREF(VALUE(mArgs), i);
+            if (!arg.isConvertibleTo(metaType)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    RubyValue invoke(QObject *obj)
+    {
+        std::array<QVariant, 10> argVariants;
+        std::array<QGenericArgument, 10> args;
+        for (int i = 0; i < mMethod.parameterCount(); ++i) {
+            auto metaType = mMethod.parameterType(i);
+            argVariants[i] = RubyValue(RARRAY_AREF(VALUE(mArgs), i)).toVariant(metaType);
+            args[i] = QGenericArgument(QMetaType::typeName(metaType), argVariants[i].data());
+        }
+
+        int returnType = mMethod.returnType();
+        if (returnType == QMetaType::UnknownType) {
+            fail("QML::MethodError", "unknown return metatype");
+        }
+        bool voidReturning = (returnType == QMetaType::Void);
+        QVariant returnValue;
+        if (!voidReturning) {
+            returnValue = QVariant(returnType, QMetaType::create(returnType));
+        }
+
+        bool result;
+        withoutGvl([&] {
+            result = mMethod.invoke(
+                        obj,
+                        Qt::DirectConnection,
+                        QGenericReturnArgument(QMetaType::typeName(returnType), returnValue.data()),
+                        args[0],args[1],args[2],args[3],args[4],
+                        args[5],args[6],args[7],args[8],args[9]);
+        });
+
+        if (!result) {
+            QString error;
+            QDebug(&error) << "failed to call method" << mMethod.methodSignature();
+            fail("QML::MethodError", error);
+        }
+        if (voidReturning) {
+            return Qnil;
+        } else {
+            auto ret = RubyValue::from(returnValue);
+            static auto objectBaseClass = RubyClass::fromPath("QML::QtObjectBase");
+            if (ret.isKindOf(objectBaseClass)) {
+                auto pointer = wrapperRubyClass<Pointer>().unwrap(ret.send("pointer"));
+                pointer->preferManaged(true);
+            }
+            return ret;
+        }
+    }
+private:
+    RubyValue mArgs;
+    QMetaMethod mMethod;
+};
+
+RubyValue MetaObject::invokeMethod(RubyValue object, RubyValue methodName, RubyValue args) const
+{
+    checkThread();
+
+    auto methodIndexes = findMethods(methodName);
+
+    protect([&] {
+        args = rb_check_array_type(args);
+    });
+    auto obj = wrapperRubyClass<Pointer>().unwrap(object)->fetchQObject();
+    for (int i : methodIndexes) {
+        MethodInvoker invoker(args, mMetaObject->method(i));
+        if (invoker.isArgsCompatible()) {
+            return invoker.invoke(obj);
+        }
+    }
+    protect([&] {
+        auto to_class = rb_funcall(ID2SYM(rb_intern("class")), rb_intern("to_proc"), 0);
+        auto classes = rb_funcall_with_block(args, rb_intern("map"), 0, nullptr, to_class);
+        auto classes_str = rb_funcall(classes, rb_intern("to_s"), 0);
+
+        rb_raise(rb_path2class("QML::MethodError"),
+                 "method mismatch (%s with params %s in %s)",
+                 mMetaObject->method(methodIndexes.first()).name().data(),
+                 StringValueCStr(classes_str),
+                 mMetaObject->className());
+    });
+    return Qnil;
+}
+
+RubyValue MetaObject::connectSignal(RubyValue object, RubyValue signalName, RubyValue proc) const
+{
+    auto id = signalName.toID();
+    auto obj = wrapperRubyClass<Pointer>().unwrap(object)->fetchQObject();
+
+    proc = proc.send("to_proc");
+
+    auto methodIndexes = mMethodHash.values(id);
+    std::reverse(methodIndexes.begin(), methodIndexes.end());
+
+    for (int i : methodIndexes) {
+        auto method = mMetaObject->method(i);
+        if (method.methodType() != QMetaMethod::Signal) {
+            continue;
+        }
+        new SignalForwarder(obj, method, proc);
+        return Qnil;
+    }
+    protect([&] {
+        rb_raise(rb_path2class("QML::MethodError"),
+                 "signal not found (%s in %s)",
+                 rb_id2name(id), mMetaObject->className());
+    });
+    return Qnil;
+}
+
+RubyValue MetaObject::propertyNames() const
+{
+    return idListToArray(mPropertyHash.keys());
+}
+
+RubyValue MetaObject::getProperty(RubyValue object, RubyValue name) const
+{
+    checkThread();
+
+    auto metaProperty = mMetaObject->property(findProperty(name));
+
+    auto qobj = wrapperRubyClass<Pointer>().unwrap(object)->fetchQObject();
+    QVariant result;
+    withoutGvl([&] {
+        result = metaProperty.read(qobj);
+    });
+    return RubyValue::from(result);
+}
+
+RubyValue MetaObject::setProperty(RubyValue object, RubyValue name, RubyValue newValue) const
+{
+    checkThread();
+
+    auto metaProperty = mMetaObject->property(findProperty(name));
+    if (!newValue.isConvertibleTo(metaProperty.userType())) {
+        protect([&] {
+            rb_raise(rb_path2class("QML::PropertyError"),
+                     "type mismatch (%s for %s)",
+                     rb_obj_classname(newValue), metaProperty.typeName());
+        });
+    }
+
+    auto qobj = wrapperRubyClass<Pointer>().unwrap(object)->fetchQObject();
+    auto variant = newValue.to<QVariant>();
+    QVariant result;
+    withoutGvl([&] {
+        metaProperty.write(qobj, variant);
+        result = metaProperty.read(qobj);
+    });
+    return RubyValue::from(result);
+}
+
+RubyValue MetaObject::notifySignal(RubyValue name) const
+{
+    auto metaProperty = mMetaObject->property(findProperty(name));
+    auto signal = metaProperty.notifySignal();
+    if (signal.isValid()) {
+        return ID2SYM(rb_intern(metaProperty.notifySignal().name()));
+    }
+    else {
+        return Qnil;
+    }
+}
+
+void MetaObject::checkThread() const
+{
+    if (rb_thread_current() != rb_thread_main()) {
+        fail("QML::InvalidThreadError", "Qt object accessed from non-main thread");
+    }
+}
+
+QList<int> MetaObject::findMethods(RubyValue name) const
+{
+    auto id = name.toID();
+    auto methodIndexes = mMethodHash.values(id);
+    if (methodIndexes.size() == 0) {
+        protect([&] {
+            rb_raise(rb_path2class("QML::MethodError"),
+                     "method not found (%s in %s)",
+                     rb_id2name(id),
+                     mMetaObject->className());
+        });
+    }
+    return methodIndexes;
+}
+
+int MetaObject::findProperty(RubyValue name) const
+{
+    auto id = name.toID();
+    if (!mPropertyHash.contains(id)) {
+        protect([&] {
+            rb_raise(rb_path2class("QML::PropertyError"),
+                     "property not found (%s in %s)",
+                     rb_id2name(id), mMetaObject->className());
+        });
+    }
+    return mPropertyHash[id];
+}
+
+RubyValue MetaObject::enumerators() const
+{
+    QHash<QByteArray, QHash<QByteArray, int>> enums;
+
+    for (int i = mMetaObject->enumeratorOffset(); i < mMetaObject->enumeratorCount(); ++i) {
+        auto metaEnum = mMetaObject->enumerator(i);
+        if (metaEnum.isFlag()) {
+            continue;
+        }
+
+        QHash<QByteArray, int> enumHash;
+        for (int j = 0; j < metaEnum.keyCount(); ++j) {
+            enumHash[metaEnum.key(j)] = metaEnum.value(j);
+        }
+        enums[metaEnum.name()] = enumHash;
+    }
+
+    return RubyValue::from(enums);
+}
+
+RubyValue MetaObject::superClass() const
+{
+    auto superclass = mMetaObject->superClass();
+    if (!superclass) {
+        return Qnil;
+    }
+    return fromMetaObject(superclass);
+}
+
+RubyValue MetaObject::isEqual(RubyValue other) const
+{
+    return RubyValue::from(mMetaObject == wrapperRubyClass<MetaObject>().unwrap(other)->mMetaObject);
+}
+
+RubyValue MetaObject::hash() const
+{
+    return RubyValue::from(reinterpret_cast<size_t>(mMetaObject)).send("hash");
+}
+
+void MetaObject::setMetaObject(const QMetaObject *metaObject)
+{
+    int methodCount = metaObject->methodCount() - metaObject->methodOffset();
+
+    QMultiHash<ID, int> methodHash;
+    QHash<ID, int> propertyHash;
+
+    for (int i = 0; i < methodCount; ++i) {
+
+        auto index = i + metaObject->methodOffset();
+        auto method = metaObject->method(index);
+
+        if (method.methodType() == QMetaMethod::Constructor) {
+            continue;
+        }
+
+        methodHash.insert(rb_intern(method.name()), index);
+    }
+
+    int propertyCount = metaObject->propertyCount() - metaObject->propertyOffset();
+
+    for (int i = 0; i < propertyCount; ++i) {
+        auto index = i + metaObject->propertyOffset();
+        auto property = metaObject->property(index);
+        propertyHash[rb_intern(property.name())] = index;
+    }
+
+    int enumCount = metaObject->enumeratorCount() - metaObject->enumeratorOffset();
+    for (int i = 0; i < enumCount; ++i) {
+        auto index = i + metaObject->enumeratorOffset();
+        auto metaEnum = metaObject->enumerator(index);
+        auto typeName = QByteArray(metaObject->className()) + "::" + QByteArray(metaEnum.name());
+        auto metaType = QMetaType::type(typeName);
+        if (metaType != QMetaType::UnknownType) {
+            RubyValue::addEnumeratorMetaType(metaType);
+        }
+    }
+
+    mMetaObject = metaObject;
+    mMethodHash = methodHash;
+    mPropertyHash = propertyHash;
+}
+
+RubyValue MetaObject::fromMetaObject(const QMetaObject *metaObject)
+{
+    auto klass = wrapperRubyClass<MetaObject>();
+    auto value = klass.newInstance();
+    klass.unwrap(value)->setMetaObject(metaObject);
+    return value;
+}
+
+void MetaObject::defineClass()
+{
+    WrapperRubyClass<MetaObject> klass(RubyModule::fromPath("QML"), "MetaObject");
+
+    klass.defineMethod("name", RUBYQML_MEMBER_FUNCTION_INFO(&MetaObject::className));
+
+    klass.defineMethod("method_names", RUBYQML_MEMBER_FUNCTION_INFO(&MetaObject::methodNames));
+    klass.defineMethod("public?", RUBYQML_MEMBER_FUNCTION_INFO(&MetaObject::isPublic));
+    klass.defineMethod("protected?", RUBYQML_MEMBER_FUNCTION_INFO(&MetaObject::isProtected));
+    klass.defineMethod("private?", RUBYQML_MEMBER_FUNCTION_INFO(&MetaObject::isPrivate));
+    klass.defineMethod("signal?", RUBYQML_MEMBER_FUNCTION_INFO(&MetaObject::isSignal));
+
+    klass.defineMethod("invoke_method", RUBYQML_MEMBER_FUNCTION_INFO(&MetaObject::invokeMethod));
+    klass.defineMethod("connect_signal", RUBYQML_MEMBER_FUNCTION_INFO(&MetaObject::connectSignal));
+
+    klass.defineMethod("property_names", RUBYQML_MEMBER_FUNCTION_INFO(&MetaObject::propertyNames));
+    klass.defineMethod("get_property", RUBYQML_MEMBER_FUNCTION_INFO(&MetaObject::getProperty));
+    klass.defineMethod("set_property", RUBYQML_MEMBER_FUNCTION_INFO(&MetaObject::setProperty));
+    klass.defineMethod("notify_signal", RUBYQML_MEMBER_FUNCTION_INFO(&MetaObject::notifySignal));
+
+    klass.defineMethod("enumerators", RUBYQML_MEMBER_FUNCTION_INFO(&MetaObject::enumerators));
+
+    klass.defineMethod("super_class", RUBYQML_MEMBER_FUNCTION_INFO(&MetaObject::superClass));
+
+    klass.defineMethod("==", RUBYQML_MEMBER_FUNCTION_INFO(&MetaObject::isEqual));
+    klass.defineMethod("hash", RUBYQML_MEMBER_FUNCTION_INFO(&MetaObject::hash));
+
+    klass.aliasMethod("eql?", "==");
+}
+
+} // namespace Ext
+} // namespace RubyQml