qml 0.0.5 → 0.0.6

data/ext/qml/rubyvalue.cpp

@@ -1,4 +1,5 @@
 #include "rubyvalue.h"
+#include "conversionerror.h"
 #include "util.h"
 #include "ext_pointer.h"
 #include "ext_metaobject.h"
@@ -22,12 +23,10 @@ namespace {
 
 RubyValue convertToString(RubyValue x)
 {
-    return protect([&] {
-        if (rb_type(x) == T_SYMBOL) {
-            x = rb_sym_to_s(x);
-        }
-        return rb_convert_type(x, T_STRING, "String", "to_str");
-    });
+    if (rb_type(x) == T_SYMBOL) {
+        x = rb_sym_to_s(x);
+    }
+    return rb_convert_type(x, T_STRING, "String", "to_str");
 }
 
 struct ConverterHash
@@ -116,9 +115,7 @@ Q_GLOBAL_STATIC(ConverterHash, converterHash)
 
 RubyValue Conversion<const char *>::to(const char *str)
 {
-    return protect([&] {
-        return rb_enc_str_new(str, strlen(str), rb_utf8_encoding());
-    });
+    return rb_enc_str_new(str, strlen(str), rb_utf8_encoding());
 }
 
 template <> QByteArray Conversion<QByteArray>::from(RubyValue x)
@@ -145,172 +142,128 @@ template <> RubyValue Conversion<QString>::to(const QString &str)
 
 template <> QDateTime Conversion<QDateTime>::from(RubyValue time)
 {
-    timeval at;
     int offset;
-    protect([&] {
-        if (rb_obj_is_kind_of(time, rb_cTime)) {
-            offset = NUM2INT(rb_funcall(time, RUBYQML_INTERN("gmt_offset"), 0));
-        } else { // DateTime
-            auto dayOffset = rb_funcall(time, RUBYQML_INTERN("offset"), 0);
-            offset = NUM2INT(RRATIONAL(dayOffset)->num) * 24 * 60 * 60 / NUM2INT(RRATIONAL(dayOffset)->den);
-            time = rb_funcall(time, RUBYQML_INTERN("to_time"), 0);
-        }
-        at = rb_time_timeval(time);
-    });
+
+    if (time.isKindOf(rb_cTime)) {
+        offset = time.send(RUBYQML_INTERN("gmt_offset")).to<int>();
+    } else { // DateTime
+        VALUE dayOffset = time.send(RUBYQML_INTERN("offset"));
+        offset = RubyValue(RRATIONAL(dayOffset)->num).to<int>() * 24 * 60 * 60 / RubyValue(RRATIONAL(dayOffset)->den).to<int>();
+        time = time.send(RUBYQML_INTERN("to_time"));
+    }
+    timeval at = rb_time_timeval(time);
+
     QDateTime dateTime;
     dateTime.setOffsetFromUtc(offset);
     dateTime.setMSecsSinceEpoch(at.tv_sec * 1000 + at.tv_usec / 1000);
     return dateTime;
 }
 
-template <> RubyValue Conversion<QDateTime>::to(const QDateTime &dateTime) {
-    RubyValue ret;
-    protect([&] {
-        auto sec = rb_rational_new(LL2NUM(dateTime.toMSecsSinceEpoch()), INT2NUM(1000));
-        auto time = rb_time_num_new(sec, INT2NUM(dateTime.offsetFromUtc()));
-        ret = rb_funcall(time, RUBYQML_INTERN("to_datetime"), 0);
-    });
-    return ret;
+template <> RubyValue Conversion<QDateTime>::to(const QDateTime &dateTime)
+{
+    RubyValue sec = rb_rational_new(RubyValue::from(dateTime.toMSecsSinceEpoch()), RubyValue::from(1000));
+    RubyValue time = rb_time_num_new(sec, RubyValue::from(dateTime.offsetFromUtc()));
+    return time.send(RUBYQML_INTERN("to_datetime"));
 }
 
 template <> QDate Conversion<QDate>::from(RubyValue x)
 {
-    int y, m, d;
-    protect([&] {
-        y = NUM2INT(rb_funcall(x, RUBYQML_INTERN("year"), 0));
-        m = NUM2INT(rb_funcall(x, RUBYQML_INTERN("month"), 0));
-        d = NUM2INT(rb_funcall(x, RUBYQML_INTERN("day"), 0));
-    });
+    int y = x.send(RUBYQML_INTERN("year")).to<int>();
+    int m = x.send(RUBYQML_INTERN("month")).to<int>();
+    int d = x.send(RUBYQML_INTERN("day")).to<int>();
     return QDate(y, m, d);
 }
 
 template <> RubyValue Conversion<QDate>::to(const QDate &date)
 {
     static auto klass = RubyClass::fromPath("Date");
-    return protect([&] {
-        return rb_funcall(klass, RUBYQML_INTERN("new"), 3,
-                          INT2NUM(date.year()), INT2NUM(date.month()), INT2NUM(date.day()));
-    });
+    return klass.toValue().send(RUBYQML_INTERN("new"), RubyValue::from(date.year()), RubyValue::from(date.month()), RubyValue::from(date.day()));
 }
 
 template <> QPoint Conversion<QPoint>::from(RubyValue value)
 {
-    int x, y;
-    protect([&] {
-        x = NUM2INT(rb_funcall(value, RUBYQML_INTERN("x"), 0));
-        y = NUM2INT(rb_funcall(value, RUBYQML_INTERN("y"), 0));
-    });
+    auto x = value.send(RUBYQML_INTERN("x")).to<int>();
+    auto y = value.send(RUBYQML_INTERN("y")).to<int>();
     return QPoint(x, y);
 }
 
 template <> RubyValue Conversion<QPoint>::to(const QPoint &point)
 {
     static auto klass = RubyClass::fromPath("QML::Geometry::Point");
-    return protect([&] {
-        return rb_funcall(klass, RUBYQML_INTERN("new"), 2,
-                          INT2NUM(point.x()), INT2NUM(point.y()));
-    });
+    return klass.toValue().send(RUBYQML_INTERN("new"), RubyValue::from(point.x()), RubyValue::from(point.y()));
 }
 
 template <> QPointF Conversion<QPointF>::from(RubyValue value)
 {
-    double x, y;
-    protect([&] {
-        x = rb_num2dbl(rb_funcall(value, RUBYQML_INTERN("x"), 0));
-        y = rb_num2dbl(rb_funcall(value, RUBYQML_INTERN("y"), 0));
-    });
+    auto x = value.send(RUBYQML_INTERN("x")).to<double>();
+    auto y = value.send(RUBYQML_INTERN("y")).to<double>();
     return QPointF(x, y);
 }
 
 template <> RubyValue Conversion<QPointF>::to(const QPointF &point)
 {
     static auto klass = RubyClass::fromPath("QML::Geometry::Point");
-    return protect([&] {
-        return rb_funcall(klass, RUBYQML_INTERN("new"), 2,
-                          rb_float_new(point.x()), rb_float_new(point.y()));
-    });
+    return klass.toValue().send(RUBYQML_INTERN("new"), RubyValue::from(point.x()), RubyValue::from(point.y()));
 }
 
 template <> QSize Conversion<QSize>::from(RubyValue value)
 {
-    int w, h;
-    protect([&] {
-        w = NUM2INT(rb_funcall(value, RUBYQML_INTERN("width"), 0));
-        h = NUM2INT(rb_funcall(value, RUBYQML_INTERN("height"), 0));
-    });
-    return QSize(w, h);
+    auto width = value.send(RUBYQML_INTERN("width")).to<int>();
+    auto height= value.send(RUBYQML_INTERN("height")).to<int>();
+    return QSize(width, height);
 }
 
 template <> RubyValue Conversion<QSize>::to(const QSize &size)
 {
     static auto klass = RubyClass::fromPath("QML::Geometry::Size");
-    return protect([&] {
-        return rb_funcall(klass, RUBYQML_INTERN("new"), 2,
-                          INT2NUM(size.width()), INT2NUM(size.height()));
-    });
+    return klass.toValue().send(RUBYQML_INTERN("new"), RubyValue::from(size.width()), RubyValue::from(size.height()));
 }
 
 template <> QSizeF Conversion<QSizeF>::from(RubyValue value)
 {
-    double w, h;
-    protect([&] {
-        w = rb_num2dbl(rb_funcall(value, RUBYQML_INTERN("width"), 0));
-        h = rb_num2dbl(rb_funcall(value, RUBYQML_INTERN("height"), 0));
-    });
-    return QSizeF(w, h);
+    auto width = value.send(RUBYQML_INTERN("width")).to<double>();
+    auto height = value.send(RUBYQML_INTERN("height")).to<double>();
+    return QSizeF(width, height);
 }
 
 template <> RubyValue Conversion<QSizeF>::to(const QSizeF &size)
 {
     static auto klass = RubyClass::fromPath("QML::Geometry::Size");
-    return protect([&] {
-        return rb_funcall(klass, RUBYQML_INTERN("new"), 2,
-                          rb_float_new(size.width()), rb_float_new(size.height()));
-    });
+    return klass.toValue().send(RUBYQML_INTERN("new"), RubyValue::from(size.width()), RubyValue::from(size.height()));
 }
 
 template <> QRect Conversion<QRect>::from(RubyValue value)
 {
-    int x, y, w, h;
-    protect([&] {
-        x = NUM2INT(rb_funcall(value, RUBYQML_INTERN("x"), 0));
-        y = NUM2INT(rb_funcall(value, RUBYQML_INTERN("y"), 0));
-        w = NUM2INT(rb_funcall(value, RUBYQML_INTERN("width"), 0));
-        h = NUM2INT(rb_funcall(value, RUBYQML_INTERN("height"), 0));
-    });
+    auto x = value.send(RUBYQML_INTERN("x")).to<int>();
+    auto y = value.send(RUBYQML_INTERN("y")).to<int>();
+    auto w = value.send(RUBYQML_INTERN("width")).to<int>();
+    auto h = value.send(RUBYQML_INTERN("height")).to<int>();
     return QRect(QPoint(x, y), QSize(w, h));
 }
 
 template <> RubyValue Conversion<QRect>::to(const QRect &rect)
 {
     static auto klass = RubyClass::fromPath("QML::Geometry::Rectangle");
-    return protect([&] {
-        return rb_funcall(klass, RUBYQML_INTERN("new"), 4,
-                          INT2NUM(rect.x()), INT2NUM(rect.y()),
-                          INT2NUM(rect.width()), INT2NUM(rect.height()));
-    });
+    return klass.toValue().send(RUBYQML_INTERN("new"),
+                                RubyValue::from(rect.x()), RubyValue::from(rect.y()),
+                                RubyValue::from(rect.width()), RubyValue::from(rect.height()));
 }
 
 template <> QRectF Conversion<QRectF>::from(RubyValue value)
 {
-    double x, y, w, h;
-    protect([&] {
-        x = rb_num2dbl(rb_funcall(value, RUBYQML_INTERN("x"), 0));
-        y = rb_num2dbl(rb_funcall(value, RUBYQML_INTERN("y"), 0));
-        w = rb_num2dbl(rb_funcall(value, RUBYQML_INTERN("width"), 0));
-        h = rb_num2dbl(rb_funcall(value, RUBYQML_INTERN("height"), 0));
-    });
-    return QRectF(QPoint(x, y), QSize(w, h));
+    auto x = value.send(RUBYQML_INTERN("x")).to<double>();
+    auto y = value.send(RUBYQML_INTERN("y")).to<double>();
+    auto w = value.send(RUBYQML_INTERN("width")).to<double>();
+    auto h = value.send(RUBYQML_INTERN("height")).to<double>();
+    return QRectF(QPointF(x, y), QSizeF(w, h));
 }
 
 template <> RubyValue Conversion<QRectF>::to(const QRectF &rect)
 {
     static auto klass = RubyClass::fromPath("QML::Geometry::Rectangle");
-    return protect([&] {
-        return rb_funcall(klass, RUBYQML_INTERN("new"), 4,
-                          rb_float_new(rect.x()), rb_float_new(rect.y()),
-                          rb_float_new(rect.width()), rb_float_new(rect.height()));
-    });
+    return klass.toValue().send(RUBYQML_INTERN("new"),
+                                RubyValue::from(rect.x()), RubyValue::from(rect.y()),
+                                RubyValue::from(rect.width()), RubyValue::from(rect.height()));
 }
 
 template <> QVariant Conversion<QVariant>::from(RubyValue x)
@@ -343,13 +296,6 @@ template <> RubyValue Conversion<const QMetaObject *>::to(const QMetaObject *met
 
 Q_GLOBAL_STATIC(QSet<int>, enumeratorMetaTypes)
 
-bool RubyValue::isKindOf(const RubyModule &module) const
-{
-    return protect([&] {
-        return rb_obj_is_kind_of(mValue, module);
-    });
-}
-
 bool RubyValue::isConvertibleTo(int metaType) const
 {
     auto x = *this;
@@ -424,58 +370,56 @@ bool RubyValue::isConvertibleTo(int metaType) const
         break;
     }
 
-    return protect([&] {
-        if (rb_obj_is_kind_of(x, rb_cTime)) {
-            return metaType == QMetaType::QDateTime;
-        }
-        static auto dateTimeClass = RubyClass::fromPath("DateTime");
-        if (rb_obj_is_kind_of(x, dateTimeClass)) {
-            return metaType == QMetaType::QDateTime;
-        }
-        static auto dateClass = RubyClass::fromPath("Date");
-        if (rb_obj_is_kind_of(x, dateClass)) {
-            return metaType == QMetaType::QDate || metaType == QMetaType::QDateTime;
+    if (rb_obj_is_kind_of(x, rb_cTime)) {
+        return metaType == QMetaType::QDateTime;
+    }
+    static auto dateTimeClass = RubyClass::fromPath("DateTime");
+    if (rb_obj_is_kind_of(x, dateTimeClass)) {
+        return metaType == QMetaType::QDateTime;
+    }
+    static auto dateClass = RubyClass::fromPath("Date");
+    if (rb_obj_is_kind_of(x, dateClass)) {
+        return metaType == QMetaType::QDate || metaType == QMetaType::QDateTime;
+    }
+    static auto objectBaseClass = RubyClass::fromPath("QML::QtObjectBase");
+    if (rb_obj_is_kind_of(x, objectBaseClass)) {
+        if (metaType == QMetaType::QObjectStar) {
+            return true;
         }
-        static auto objectBaseClass = RubyClass::fromPath("QML::QtObjectBase");
-        if (rb_obj_is_kind_of(x, objectBaseClass)) {
-            if (metaType == QMetaType::QObjectStar) {
+        if (QMetaType::metaObjectForType(metaType)) {
+            auto metaObj = QMetaType::metaObjectForType(metaType);
+            if (x.to<QObject *>()->inherits(metaObj->className())) {
                 return true;
             }
-            if (QMetaType::metaObjectForType(metaType)) {
-                auto metaObj = QMetaType::metaObjectForType(metaType);
-                if (x.to<QObject *>()->inherits(metaObj->className())) {
-                    return true;
-                }
-            }
-            return false;
-        }
-        if (rb_obj_is_kind_of(x, wrapperRubyClass<Ext_MetaObject>())) {
-            return metaType == QMetaType::type("const QMetaObject*");
-        }
-        auto accessModule = RubyModule::fromPath("QML::Access");
-        if (rb_obj_is_kind_of(x, accessModule)) {
-            return metaType == QMetaType::QObjectStar;
         }
+        return false;
+    }
+    if (rb_obj_is_kind_of(x, wrapperRubyClass<Ext_MetaObject>())) {
+        return metaType == QMetaType::type("const QMetaObject*");
+    }
+    auto accessModule = RubyModule::fromPath("QML::Access");
+    if (rb_obj_is_kind_of(x, accessModule)) {
+        return metaType == QMetaType::QObjectStar;
+    }
 
-        static auto pointClass = RubyModule::fromPath("QML::Geometry::Point");
-        if (rb_obj_is_kind_of(x, pointClass)) {
-            return metaType == QMetaType::QPoint || metaType == QMetaType::QPointF;
-        }
-        static auto sizeClass = RubyModule::fromPath("QML::Geometry::Size");
-        if (rb_obj_is_kind_of(x, sizeClass)) {
-            return metaType == QMetaType::QSize || metaType == QMetaType::QSizeF;
-        }
-        static auto rectClass = RubyModule::fromPath("QML::Geometry::Rectangle");
-        if (rb_obj_is_kind_of(x, rectClass)) {
-            return metaType == QMetaType::QRect || metaType == QMetaType::QRectF;
-        }
-        static auto listModelClass = RubyModule::fromPath("QML::Data::ListModel");
+    static auto pointClass = RubyModule::fromPath("QML::Geometry::Point");
+    if (rb_obj_is_kind_of(x, pointClass)) {
+        return metaType == QMetaType::QPoint || metaType == QMetaType::QPointF;
+    }
+    static auto sizeClass = RubyModule::fromPath("QML::Geometry::Size");
+    if (rb_obj_is_kind_of(x, sizeClass)) {
+        return metaType == QMetaType::QSize || metaType == QMetaType::QSizeF;
+    }
+    static auto rectClass = RubyModule::fromPath("QML::Geometry::Rectangle");
+    if (rb_obj_is_kind_of(x, rectClass)) {
+        return metaType == QMetaType::QRect || metaType == QMetaType::QRectF;
+    }
+    static auto listModelClass = RubyModule::fromPath("QML::Data::ListModel");
 
-        if (rb_obj_is_kind_of(x, listModelClass)) {
-            return metaType == QMetaType::QObjectStar;
-        }
-        return false;
-    });
+    if (rb_obj_is_kind_of(x, listModelClass)) {
+        return metaType == QMetaType::QObjectStar;
+    }
+    return false;
 }
 
 int RubyValue::defaultMetaType() const
@@ -507,50 +451,48 @@ int RubyValue::defaultMetaType() const
     default:
         break;
     }
-    return protect([&]() -> int {
-        if (rb_obj_is_kind_of(x, rb_cTime)) {
-            return QMetaType::QDateTime;
-        }
-        static auto dateTimeClass = RubyModule::fromPath("DateTime");
-        if (rb_obj_is_kind_of(x, dateTimeClass)) {
-            return QMetaType::QDateTime;
-        }
-        static auto dateClass = RubyModule::fromPath("Date");
-        if (rb_obj_is_kind_of(x, dateClass)) {
-            return QMetaType::QDate;
-        }
+    if (rb_obj_is_kind_of(x, rb_cTime)) {
+        return QMetaType::QDateTime;
+    }
+    static auto dateTimeClass = RubyModule::fromPath("DateTime");
+    if (rb_obj_is_kind_of(x, dateTimeClass)) {
+        return QMetaType::QDateTime;
+    }
+    static auto dateClass = RubyModule::fromPath("Date");
+    if (rb_obj_is_kind_of(x, dateClass)) {
+        return QMetaType::QDate;
+    }
 
-        static auto objectBaseClass = RubyClass::fromPath("QML::QtObjectBase");
-        if (rb_obj_is_kind_of(x, objectBaseClass)) {
-            return QMetaType::QObjectStar;
-        }
-        if (rb_obj_is_kind_of(x, wrapperRubyClass<Ext_MetaObject>())) {
-            return QMetaType::type("const QMetaObject*");
-        }
-        auto accessModule = RubyModule::fromPath("QML::Access");
-        if (rb_obj_is_kind_of(x, accessModule)) {
-            return QMetaType::QObjectStar;
-        }
+    static auto objectBaseClass = RubyClass::fromPath("QML::QtObjectBase");
+    if (rb_obj_is_kind_of(x, objectBaseClass)) {
+        return QMetaType::QObjectStar;
+    }
+    if (rb_obj_is_kind_of(x, wrapperRubyClass<Ext_MetaObject>())) {
+        return QMetaType::type("const QMetaObject*");
+    }
+    auto accessModule = RubyModule::fromPath("QML::Access");
+    if (rb_obj_is_kind_of(x, accessModule)) {
+        return QMetaType::QObjectStar;
+    }
 
-        static auto pointClass = RubyModule::fromPath("QML::Geometry::Point");
-        if (rb_obj_is_kind_of(x, pointClass)) {
-            return QMetaType::QPointF;
-        }
-        static auto sizeClass = RubyModule::fromPath("QML::Geometry::Size");
-        if (rb_obj_is_kind_of(x, sizeClass)) {
-            return QMetaType::QSizeF;
-        }
-        static auto rectClass = RubyModule::fromPath("QML::Geometry::Rectangle");
-        if (rb_obj_is_kind_of(x, rectClass)) {
-            return QMetaType::QRectF;
-        }
+    static auto pointClass = RubyModule::fromPath("QML::Geometry::Point");
+    if (rb_obj_is_kind_of(x, pointClass)) {
+        return QMetaType::QPointF;
+    }
+    static auto sizeClass = RubyModule::fromPath("QML::Geometry::Size");
+    if (rb_obj_is_kind_of(x, sizeClass)) {
+        return QMetaType::QSizeF;
+    }
+    static auto rectClass = RubyModule::fromPath("QML::Geometry::Rectangle");
+    if (rb_obj_is_kind_of(x, rectClass)) {
+        return QMetaType::QRectF;
+    }
 
-        static auto listModelClass = RubyModule::fromPath("QML::Data::ListModel");
-        if (rb_obj_is_kind_of(x, listModelClass)) {
-            return  QMetaType::QObjectStar;
-        }
-        return QMetaType::UnknownType;
-    });
+    static auto listModelClass = RubyModule::fromPath("QML::Data::ListModel");
+    if (rb_obj_is_kind_of(x, listModelClass)) {
+        return  QMetaType::QObjectStar;
+    }
+    return QMetaType::UnknownType;
 }
 
 RubyValue RubyValue::fromVariant(const QVariant &variant)
@@ -565,9 +507,8 @@ RubyValue RubyValue::fromVariant(const QVariant &variant)
         return from(intValue);
     }
     if (!hash.contains(type)) {
-        fail("QML::ConversionError",
-             QString("failed to convert QVariant value (%1)")
-             .arg(QMetaType::typeName(type)));
+        throw ConversionError(QString("failed to convert QVariant value (%1)")
+                             .arg(QMetaType::typeName(type)));
     }
     return hash[type](variant);
 }
@@ -588,10 +529,9 @@ QVariant RubyValue::toVariant(int type) const
             if (qobj->inherits(metaobj->className())) {
                 return QVariant::fromValue(qobj);
             }
-            fail("QML::ConversionError",
-                 QString("failed to convert QObject value (%1 to %2)")
-                 .arg(qobj->metaObject()->className())
-                 .arg(metaobj->className()));
+            throw ConversionError(QString("failed to convert QObject value (%1 to %2)")
+                                  .arg(qobj->metaObject()->className())
+                                  .arg(metaobj->className()));
         }
         if (enumeratorMetaTypes->contains(type)) {
             auto intValue = to<int>();
@@ -599,10 +539,9 @@ QVariant RubyValue::toVariant(int type) const
             *static_cast<int *>(data) = intValue;
             return QVariant(type, data);
         }
-        fail("QML::ConversionError",
-             QString("failed to convert Ruby value (%1 to %2)")
-             .arg(rb_obj_classname(x))
-             .arg(QMetaType::typeName(type)));
+        throw ConversionError(QString("failed to convert Ruby value (%1 to %2)")
+                              .arg(rb_obj_classname(x))
+                              .arg(QMetaType::typeName(type)));
         return QVariant();
     }
     return hash[type](x);
@@ -634,12 +573,12 @@ RubyValue RubyValue::fromQObject(QObject *obj, bool implicit)
     auto pointer = Ext_Pointer::fromQObject(obj, false);
 
     RubyValue wrapper;
-    protect([&] {
-        auto klass = rb_funcall(metaobj, RUBYQML_INTERN("build_class"), 0);
-        wrapper = rb_obj_alloc(klass);
-        rb_funcall(wrapper, RUBYQML_INTERN("pointer="), 1, pointer);
-        rb_obj_call_init(wrapper, 0, nullptr);
-    });
+
+    auto klass = rb_funcall(metaobj, RUBYQML_INTERN("build_class"), 0);
+    wrapper = rb_obj_alloc(klass);
+    rb_funcall(wrapper, RUBYQML_INTERN("pointer="), 1, pointer);
+    rb_obj_call_init(wrapper, 0, nullptr);
+
     data->rubyObject = wrapper;
     return wrapper;
 }
@@ -653,9 +592,7 @@ QObject *RubyValue::toQObject() const
     }
     static auto accessModule = RubyModule::fromPath("QML::Access");
     if (x.isKindOf(accessModule)) {
-        auto wrapperFactory = protect([&] {
-            return rb_funcall(rb_obj_class(x), RUBYQML_INTERN("access_wrapper_factory"), 0);
-        });
+        auto wrapperFactory = rb_funcall(rb_obj_class(x), RUBYQML_INTERN("access_wrapper_factory"), 0);
         return wrapperRubyClass<Ext_AccessWrapperFactory>().unwrap(wrapperFactory)->create(x);
     }
     static auto listModelClass = RubyModule::fromPath("QML::Data::ListModel");
@@ -665,9 +602,8 @@ QObject *RubyValue::toQObject() const
 
     static auto objectBaseClass = RubyClass::fromPath("QML::QtObjectBase");
     if (!x.isKindOf(objectBaseClass)) {
-        fail("QML::ConversionError",
-             QString("expected QML::QtObjectbase, got %1")
-                .arg(x.send("class").send("name").to<QString>()));
+        throw ConversionError(QString("expected QML::QtObjectbase, got %1")
+                              .arg(x.send("class").send("name").to<QString>()));
     }
     auto objptr = x.send(RUBYQML_INTERN("pointer"));
     auto obj = wrapperRubyClass<Ext_Pointer>().unwrap(objptr)->fetchQObject();
@@ -677,9 +613,7 @@ QObject *RubyValue::toQObject() const
 
 ID RubyValue::toID() const
 {
-    return protect([&] {
-        return SYM2ID(rb_convert_type(*this, T_SYMBOL, "Symbol", "to_sym"));
-    });
+    return SYM2ID(rb_convert_type(*this, T_SYMBOL, "Symbol", "to_sym"));
 }
 
 void RubyValue::addEnumeratorMetaType(int metaType)