qml 0.0.5 → 0.0.6

data/ext/qml/rubyvalue.h

@@ -42,11 +42,7 @@ public:
     template <typename ... TArgs>
     RubyValue send(ID method, TArgs ... args) const
     {
-        constexpr int argc = sizeof...(args);
-        std::array<VALUE, argc> argv = {{ VALUE(args)... }};
-        return protect([&] {
-            return rb_funcall2(mValue, method, argc, argv.data());
-        });
+        return rb_funcall(mValue, method, sizeof...(args), args...);
     }
 
     template <typename ... TArgs>
@@ -59,7 +55,11 @@ public:
     bool operator!=(const RubyValue &other) const { return !operator==(other); }
     explicit operator bool() const { return RTEST(mValue); }
 
-    bool isKindOf(const RubyModule &module) const;
+    bool isKindOf(const RubyValue &module) const
+    {
+        return RTEST(rb_obj_is_kind_of(mValue, module));
+    }
+
     bool isConvertibleTo(int metaType) const;
     int defaultMetaType() const;
 
@@ -99,16 +99,8 @@ struct Conversion<bool>
 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 protect([&] {
-            return NUM2LL(x);
-        });
-    }
-    static RubyValue to(T x)
-    {
-        return LL2NUM(x);
-    }
+    static T from(RubyValue x) { return NUM2LL(x); }
+    static RubyValue to(T x) { return LL2NUM(x); }
 };
 
 // unsigned integers
@@ -116,16 +108,8 @@ struct Conversion<T, typename std::enable_if<std::is_signed<T>::value && std::is
 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 protect([&] {
-            return NUM2ULL(x);
-        });
-    }
-    static RubyValue to(T x)
-    {
-        return ULL2NUM(x);
-    }
+    static T from(RubyValue x) { return NUM2ULL(x); }
+    static RubyValue to(T x) { return ULL2NUM(x); }
 };
 
 // floating point values
@@ -135,14 +119,12 @@ struct Conversion<T, typename std::enable_if<std::is_floating_point<T>::value>::
 {
     static T from(RubyValue x)
     {
-        return protect([&] {
-            auto type = rb_type(x);
-            if (type == T_FIXNUM || type == T_BIGNUM) {
-                return double(NUM2LL(x));
-            } else {
-                return RFLOAT_VALUE(VALUE(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)
     {
@@ -161,9 +143,7 @@ struct Conversion<T<V>, typename std::enable_if<IsQListLike<T<V>>::value>::type>
 {
     static T<V> from(RubyValue x)
     {
-        protect([&] {
-            x = rb_convert_type(x, T_ARRAY, "Array", "to_ary");
-        });
+        x = rb_convert_type(x, T_ARRAY, "Array", "to_ary");
         int length = RARRAY_LEN(VALUE(x));
         T<V> list;
         list.reserve(length);
@@ -174,14 +154,10 @@ struct Conversion<T<V>, typename std::enable_if<IsQListLike<T<V>>::value>::type>
     }
     static RubyValue to(const T<V> &list)
     {
-        RubyValue ary = protect([&] {
-            return rb_ary_new();
-        });
+        auto ary = rb_ary_new();
         for (const auto &elem : list) {
             auto x = RubyValue::from(elem);
-            protect([&] {
-                rb_ary_push(ary, x);
-            });
+            rb_ary_push(ary, x);
         }
         return ary;
     }
@@ -198,34 +174,25 @@ struct Conversion<T<K, V>, typename std::enable_if<IsQHashLike<T<K, V>>::value>:
 {
     static T<K, V> from(RubyValue x)
     {
-        protect([&] {
-            x = rb_convert_type(x, T_HASH, "Hash", "to_hash");
-        });
+        x = rb_convert_type(x, T_HASH, "Hash", "to_hash");
+
         T<K, V> hash;
-        protect([&] {
-            auto each = [](VALUE key, VALUE value, VALUE arg) -> int {
-                auto &hash = *reinterpret_cast<T<K, V> *>(arg);
-                unprotect([&] {
-                    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));
-        });
+        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)
     {
-        RubyValue rubyHash = protect([&] {
-            return rb_hash_new();
-        });
+        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());
-            protect([&] {
-                rb_hash_aset(rubyHash, k, v);
-            });
+            rb_hash_aset(rubyHash, k, v);
         }
         return rubyHash;
     }

data/ext/qml/signalforwarder.cpp

@@ -56,9 +56,7 @@ void SignalForwarder::callProc(const QVariantList &list)
     if (mProcRef.hasValue()) {
         withGvl([&] {
             auto args = RubyValue::from(list);
-            protect([&] {
-                rb_funcall2(mProcRef.value(), rb_intern("call"), RARRAY_LEN(VALUE(args)), RARRAY_PTR(VALUE(args)));
-            });
+            rb_apply(mProcRef.value(), RUBYQML_INTERN("call"), args);
         });
     }
 }

data/ext/qml/util.cpp

@@ -16,32 +16,14 @@ void *rb_thread_call_without_gvl(void *(*func)(void *), void *data1, rb_unblock_
 
 namespace RubyQml {
 
-void protect(const std::function<void ()> &doAction)
+void convertCppErrors(const std::function<void ()> &doAction) noexcept
 {
-    auto callback = [](VALUE data) {
-        auto &doAction= *reinterpret_cast<const std::function<void ()> *>(data);
-        doAction();
-        return Qnil;
-    };
-    int state;
-    rb_protect(callback, reinterpret_cast<VALUE>(&doAction), &state);
-    if (state) {
-        throw RubyException(state);
-    }
-}
-
-void unprotect(const std::function<void ()> &doAction) noexcept
-{
-    int state = 0;
     bool cppErrorOccured= false;
     VALUE cppErrorClassName = Qnil;
     VALUE cppErrorMessage = Qnil;
     try {
         doAction();
     }
-    catch (const RubyException &ex) {
-        state = ex.state();
-    }
     catch (const std::exception &ex) {
         cppErrorOccured = true;
         int status;
@@ -50,9 +32,6 @@ void unprotect(const std::function<void ()> &doAction) noexcept
         free(classname);
         cppErrorMessage = rb_str_new_cstr(ex.what());
     }
-    if (state) {
-        rb_jump_tag(state);
-    }
     if (cppErrorOccured) {
         auto patterns = rb_funcall(rb_path2class("QML::ErrorConverter"), rb_intern("patterns"), 0);
         auto rubyClass = rb_hash_aref(patterns, cppErrorClassName);
@@ -127,9 +106,7 @@ void withGvl(const std::function<void ()> &doAction)
 void fail(const char *errorClassName, const QString &message)
 {
     auto msg = message.toUtf8();
-    protect([&] {
-        rb_raise(rb_path2class(errorClassName), "%s", msg.data());
-    });
+    rb_raise(rb_path2class(errorClassName), "%s", msg.data());
 }
 
 }

data/ext/qml/util.h

@@ -54,27 +54,7 @@ private:
     int mState = 0;
 };
 
-
-// Convert Ruby exceptions into C++ exceptions (RubyException)
-void protect(const std::function<void()> &doAction);
-
-template <typename F>
-typename std::enable_if<
-    !std::is_same<typename std::result_of<F()>::type, void>::value,
-    typename std::result_of<F()>::type>::type
-protect(const F &doAction)
-{
-    typename std::result_of<F()>::type ret;
-    protect([&] {
-        ret = doAction();
-    });
-    return ret;
-}
-
-// Regenerate Ruby exceptions that are converted into RubyException
-// and convert std::exception exceptions into Ruby errors.
-// Other C++ exceptions are not allowed to be thrown out of this function.
-void unprotect(const std::function<void()> &doAction) noexcept;
+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);

data/ext/qml/weakvaluereference.cpp

@@ -32,11 +32,10 @@ WeakValueReference::WeakValueReference(RubyValue value) :
     d->mHasValue = true;
     d->mValue = value;
     static auto objspace = RubyModule::fromPath("ObjectSpace");
-    protect([&] {
-        auto proc = rb_proc_new((VALUE (*)(...))&Data::finalize, Ext_AnyWrapper::create(QVariant::fromValue(d)));
-        VALUE args[] = { value };
-        rb_funcall_with_block(objspace, RUBYQML_INTERN("define_finalizer"), 1, args, proc);
-    });
+
+    auto proc = rb_proc_new((VALUE (*)(...))&Data::finalize, Ext_AnyWrapper::create(QVariant::fromValue(d)));
+    VALUE args[] = { value };
+    rb_funcall_with_block(objspace, RUBYQML_INTERN("define_finalizer"), 1, args, proc);
 }
 
 bool WeakValueReference::hasValue() const

data/lib/qml/access.rb

@@ -11,13 +11,11 @@ module QML
     include Dispatchable
     include Wrappable
     # @!parse include Reactive::Object
-    # @!parse include SignalInitialization
     # @!parse extend ClassMethods
 
     def self.included(derived)
       derived.class_eval do
         include Reactive::Object
-        include SignalInitialization
         extend ClassMethods
       end
     end
@@ -113,26 +111,20 @@ module QML
       end
     end
 
-    module SignalInitialization
-      def initialize(*args, &block)
-        super
-        signal_names = signals + properties.map { |name| :"#{name}_changed" }
-        signal_names.each do |name|
-          __send__(name).connect do |*args|
-            @access_wrappers.each do |obj|
-              obj.class.meta_object.invoke_method(obj.pointer, name, args)
-            end
-          end
-        end
-      end
-    end
-
     # @api private
     attr_reader :access_wrappers
 
     def initialize(*args, &block)
-      super
+      signal_names = signals + properties.map { |name| :"#{name}_changed" }
+      signal_names.each do |name|
+        __send__(name).connect do |*args|
+          @access_wrappers.each do |obj|
+            obj.class.meta_object.invoke_method(obj.pointer, name, args)
+          end
+        end
+      end
       @access_wrappers = []
+      super
     end
 
     def create_wrapper

data/lib/qml/application.rb

@@ -106,29 +106,26 @@ module QML
     end
   end
 
-  # @overload application
-  #   Returns the instance of {Application}.
-  #   @return [Application]
-  # @overload application
-  #   Call {init} if ruby-qml is not initialized, then yields the application instance and then call {Application#exec}.
-  #   @return [Application]
-  #   @example
-  #     QML.application do |app|
-  #       app.context[:foo] = 'foo'
-  #       app.load_path Pathname(__FILE__) + '../main.qml'
-  #     end
-  # @see Application.instance
+  # Returns the instance of {Application}.
+  # @return [Application]
   def application
-    if block_given?
-      QML.init unless QML.initialized?
-      Application.instance.tap do |app|
-        yield app
-        app.exec
-      end
-    else
-      Application.instance
+    Application.instance
+  end
+
+  # Call {init} if ruby-qml is not initialized, then yields the application instance and then call {Application#exec}.
+  # @return [Application]
+  # @example
+  #   QML.run do |app|
+  #     app.context[:foo] = 'foo'
+  #     app.load_path Pathname(__FILE__) + '../main.qml'
+  #   end
+  def run
+    QML.init unless QML.initialized?
+    Application.instance.tap do |app|
+      yield app
+      app.exec
     end
   end
 
-  module_function :application
+  module_function :application, :run
 end

data/lib/qml/context.rb

@@ -10,7 +10,7 @@ module QML
   # @see http://qt-project.org/doc/qt-5/qqmlcontext.html QQmlContext(C++)
   #
   # @example
-  #   QML.application do |app|
+  #   QML.run do |app|
   #     app.context[:foo] = 'foo'
   #     app.context[:bar] = 'bar'
   #     ...

data/lib/qml/dispatcher.rb

@@ -43,7 +43,6 @@ module QML
 
   on_init do
     Kernel.event_loop_hook_timer.timeout.connect do
-      puts "======== run tasks"
       Dispatcher.instance.run_tasks
     end
   end

data/lib/qml/error_converter.rb

@@ -11,5 +11,6 @@ module QML
     end
 
     add_pattern 'RubyQml::QmlException', QMLError
+    add_pattern 'RubyQml::ConversionError', ConversionError
   end
 end

data/lib/qml/meta_object.rb

@@ -1,5 +1,5 @@
 require 'qml/qml'
-require 'qml/class_builder'
+require 'qml/qt_object_base'
 
 module QML
   class MetaObject
@@ -12,9 +12,9 @@ module QML
     def build_class
       @@classes ||= {}
       klass = @@classes[name]
-      builder = ClassBuilder.new(self, klass)
+      builder = QtObjectBase::SubclassBuilder.new(self, klass)
       builder.build
-      @@classes[name] = builder.klass
+      @@classes[name] = builder.subclass
     end
   end
 end

data/lib/qml/qt_object_base.rb

@@ -1,7 +1,50 @@
 require 'qml/dispatchable'
+require 'qml/name_helper'
 
 module QML
 
+  class QtPropertyBase
+    attr_reader :changed
+
+    def initialize(metaobj, objptr, name)
+      super()
+      @metaobj = metaobj
+      @objptr = objptr
+      @name = name
+      @changed = QtSignal.new(metaobj, objptr, @metaobj.notify_signal(@name))
+    end
+
+    def value=(newval)
+      @metaobj.set_property(@objptr, @name, newval)
+    end
+
+    def value
+      @metaobj.get_property(@objptr, @name)
+    end
+  end
+
+  class QtProperty < QtPropertyBase
+    include Reactive::Bindable
+  end
+
+  class QtSignal < Reactive::Signal
+    def initialize(metaobj, objptr, name)
+      super(nil)
+      @objptr = objptr
+      @metaobj = metaobj
+      @name = name
+      @initialized = false
+    end
+
+    private
+
+    def connected(block)
+      return if @initialized
+      @metaobj.connect_signal(@objptr, @name, method(:emit))
+      @initialized = true
+    end
+  end
+
   # {QtObjectBase} is the base class for Qt object wrappers.
   #
   # In ruby-qml you can access the followings of Qt objects in Ruby.
@@ -33,6 +76,93 @@ module QML
     include Dispatchable
     include Reactive::Object
 
+    # @api private
+    class SubclassBuilder
+
+      attr_reader :subclass
+
+      def initialize(metaobj, klass)
+        @metaobj = metaobj
+        @subclass = klass
+      end
+
+      def build
+        create unless @subclass
+        return if @subclass.meta_object == @metaobj
+
+        @metaobj.method_names.reject { |name| @metaobj.signal?(name) }.each do |name|
+          define_method(name)
+        end
+        @metaobj.method_names.select { |name| @metaobj.signal?(name) }.each do |name|
+          define_signal(name)
+        end
+        @metaobj.property_names.each do |name|
+          define_property(name)
+        end
+        @metaobj.enumerators.each do |k, v|
+          define_enum(k, v)
+        end
+        @subclass.__send__ :meta_object=, @metaobj
+
+        self
+      end
+
+      private
+
+      def create
+        super_metaobj = @metaobj.super_class
+        @subclass = Class.new(super_metaobj ? super_metaobj.build_class : QtObjectBase)
+      end
+
+      def define_method(name)
+        metaobj = @metaobj
+        return if metaobj.private?(name)
+        underscore = NameHelper.to_underscore(name)
+
+        @subclass.class_eval do
+          define_method name do |*args|
+            metaobj.invoke_method(@pointer, name, args)
+          end
+          private name if metaobj.protected?(name)
+          alias_method underscore, name unless underscore == name
+        end
+      end
+
+      def define_signal(name)
+        metaobj = @metaobj
+        underscore = NameHelper.to_underscore(name)
+        @subclass.class_eval do
+          variadic_signal name, signal: -> { QtSignal.new(metaobj, @pointer, name) }
+          alias_signal underscore, name unless underscore == name
+        end
+      end
+
+      def define_property(name)
+        metaobj = @metaobj
+        underscore = NameHelper.to_underscore(name)
+        @subclass.class_eval do
+          property name, nil, property: -> { QtProperty.new(metaobj, @pointer, name) }
+          alias_property underscore, name unless underscore == name
+        end
+      end
+
+      def define_enum(name, hash)
+        define_const(name, hash.values.sort)
+        hash.each do |k, v|
+          define_const(k, v)
+        end
+      end
+
+      def define_const(name, value)
+        name = (name[0].capitalize + name[1..-1]).to_sym
+        underscore = NameHelper.to_upper_underscore(name)
+        @subclass.class_eval do
+          const_set name, value
+          const_set underscore, value unless underscore == name
+        end
+      end
+    end
+
     class << self
       attr_accessor :meta_object
       private :meta_object=
@@ -41,11 +171,6 @@ module QML
     attr_accessor :pointer
     private :pointer=
 
-    # @api private
-    def custom_data
-      @custom_data ||= {}
-    end
-
     # Evaluates a JavaScript expression on the QML context of the object.
     # Fails with {QMLError} when the object is not created by QML and does not belong to any context.
     # @param [String] str