qml 0.0.1 → 0.0.2

data/examples/twitter/twitter.rb

@@ -2,43 +2,53 @@ $LOAD_PATH.unshift File.expand_path('../../../lib', __FILE__)
 require 'qml'
 require 'twitter'
 require 'yaml'
+require 'celluloid'
 
 module Examples
   module Twitter
     VERSION = '0.1'
 
-    class TwitterModel < QML::Data::ArrayModel
-      column :tweet_text, :user_name, :user_icon
+    class TweetFetcher
+      def initialize
+        config_data = YAML.load((Pathname(__FILE__) + '../config.yml').read)
+        config_keys = %w{consumer_key consumer_secret access_token access_token_secret}
+
+        @rest_client = ::Twitter::REST::Client.new do |config|
+          config_keys.each do |key|
+            config.public_send("#{key}=", config_data[key])
+          end
+        end
+        @streaming_client = ::Twitter::Streaming::Client.new do |config|
+          config_keys.each do |key|
+            config.public_send("#{key}=", config_data[key])
+          end
+        end
+      end
+
+      def start(word)
+        puts "word = #{word}"
+        @rest_client.search(word).take(10).each do |t|
+          yield t
+        end
+        @streaming_client.filter(track: word) do |object|
+          case object
+          when ::Twitter::Tweet
+            puts object
+            QML.later { yield object }
+          end
+        end
+      end
     end
 
     class TwitterController
       include QML::Access
       register_to_qml
 
-      property :model, TwitterModel.new
+      property :model, QML::Data::ArrayModel.new(:tweet_text, :user_name, :user_icon)
+      property :word
 
       def initialize
         super()
-
-        streaming_client = ::Twitter::Streaming::Client.new do |config|
-          data = YAML.load((Pathname(__FILE__) + '../config.yml').read)
-          %w{consumer_key consumer_secret access_token access_token_secret}.each do |key|
-            config.public_send("#{key}=", data[key])
-          end
-        end
-
-        Thread.new do
-          begin
-            streaming_client.user do |object|
-              case object
-              when ::Twitter::Tweet
-                later.add_tweet(object)
-              end
-            end
-          rescue => e
-            puts e.message
-          end
-        end
       end
 
       def add_tweet(tweet)
@@ -46,6 +56,19 @@ module Examples
         puts hash
         model.unshift hash
       end
+
+      def fetch_tweets
+        model.clear
+        if @thread
+          @thread.kill
+        end
+        word = self.word
+        @thread = Thread.new do
+          TweetFetcher.new.start(word) do |tweet|
+            later.add_tweet(tweet)
+          end
+        end
+      end
     end
   end
 end

data/ext/qml/accessclass.cpp

@@ -47,10 +47,8 @@ QVariant AccessClass::callMethod(ForeignObject *obj, size_t id, const QVariantLi
         std::transform(args.begin(), args.end(), values.begin(), &RubyValue::from<QVariant>);
         RubyValue retValue;
         protect([&] {
-            rescue([&] {
+            rescueNotify([&] {
                 retValue = rb_funcall2(self, id, values.size(), values.data());
-            }, [&](RubyValue excObject) {
-                rb_funcall(rb_path2class("QML::Application"), rb_intern("notify_error"), 1, excObject);
             });
         });
         ret = retValue.to<QVariant>();

data/ext/qml/ext_anywrapper.cpp

@@ -0,0 +1,36 @@
+#include "ext_anywrapper.h"
+#include "rubyclass.h"
+
+namespace RubyQml {
+namespace Ext {
+
+AnyWrapper::AnyWrapper(RubyValue self)
+{
+    Q_UNUSED(self);
+}
+
+RubyValue AnyWrapper::create(const QVariant &value, void (*markFunction)(const QVariant &))
+{
+    auto klass = wrapperRubyClass<AnyWrapper>();
+    auto wrapper = klass.newInstance();
+    auto ptr = klass.unwrap(wrapper);
+    ptr->mValue = value;
+    ptr->mMarkFunction = markFunction;
+    return wrapper;
+}
+
+void AnyWrapper::defineClass()
+{
+    WrapperRubyClass<AnyWrapper> klass(RubyModule::fromPath("QML"), "AnyWrapper");
+    Q_UNUSED(klass);
+}
+
+void AnyWrapper::gc_mark()
+{
+    if (mMarkFunction) {
+        mMarkFunction(mValue);
+    }
+}
+
+} // namespace Ext
+} // namespace RubyQml

data/ext/qml/ext_anywrapper.h

@@ -0,0 +1,26 @@
+#pragma once
+#include <QVariant>
+
+namespace RubyQml {
+
+class RubyValue;
+
+namespace Ext {
+
+class AnyWrapper
+{
+public:
+    AnyWrapper(RubyValue self);
+    static RubyValue create(const QVariant &value, void (*markFunction)(const QVariant &) = nullptr);
+    static void defineClass();
+
+    QVariant value() const { return mValue; }
+    void gc_mark();
+
+private:
+    QVariant mValue;
+    void (*mMarkFunction)(const QVariant &);
+};
+
+} // namespace Ext
+} // namespace RubyQml

data/ext/qml/ext_metaobject.cpp

@@ -106,7 +106,9 @@ public:
         bool voidReturning = (returnType == QMetaType::Void);
         QVariant returnValue;
         if (!voidReturning) {
-            returnValue = QVariant(returnType, QMetaType::create(returnType));
+            auto data = QMetaType::create(returnType);
+            returnValue = QVariant(returnType, data);
+            QMetaType::destroy(returnType, data);
         }
 
         bool result;

data/ext/qml/init.cpp

@@ -1,7 +1,7 @@
 #include "ext_metaobject.h"
 #include "ext_pointer.h"
 #include "ext_pluginloader.h"
-#include "ext_gcmarker.h"
+#include "ext_anywrapper.h"
 #include "ext_accesssupport.h"
 #include "ext_testutil.h"
 #include "ext_kernel.h"
@@ -26,7 +26,7 @@ void defineClasses()
     Ext::MetaObject::defineClass();
     Ext::Pointer::defineClass();
     Ext::PluginLoader::defineClass();
-    Ext::GCMarker::defineClass();
+    Ext::AnyWrapper::defineClass();
     Ext::AccessWrapperFactory::defineClass();
     Ext::TestUtil::defineModule();
     Ext::Kernel::defineModule();
@@ -35,7 +35,7 @@ void defineClasses()
 
 void setupGlobalGCMarking()
 {
-    auto marker = Ext::GCMarker::fromMarkFunction([] {
+    auto marker = Ext::AnyWrapper::create(QVariant(), [](const QVariant &) {
         ValueReference::markAllReferences();
         ObjectGC::instance()->markNonOwnedObjects();
     });

data/ext/qml/listmodel.cpp

@@ -9,7 +9,7 @@ ListModel::ListModel(RubyValue rubyModel, QObject *parent) :
     QAbstractListModel(parent),
     mRubyModel(rubyModel)
 {
-    auto columns = rubyModel.send("class").send("columns").to<QList<QByteArray>>();
+    auto columns = rubyModel.send("columns").to<QList<QByteArray>>();
     for (int i = 0; i < columns.size(); ++i) {
         auto role = Qt::UserRole + i;
         mColumnNames[role] = columns[i];
@@ -34,7 +34,17 @@ QVariant ListModel::data(const QModelIndex &index, int role) const
         return QVariant();
     }
 
-    return mRubyModel.send("[]", RubyValue::from(index.row())).send("[]", RubyValue::fromID(mColumnIDs[role])).to<QVariant>();
+    QVariant result;
+    withGvl([&] {
+        RubyValue value;
+        rescueNotify([&] {
+            auto subscribe = RUBYQML_INTERN("[]");
+            auto record = rb_funcall(mRubyModel, subscribe, 1, INT2NUM(index.row()));
+            value = rb_funcall(record, subscribe, 1, ID2SYM(mColumnIDs[role]));
+        });
+        result = value.toVariant();
+    });
+    return result;
 }
 
 int ListModel::rowCount(const QModelIndex &parent) const
@@ -42,8 +52,13 @@ int ListModel::rowCount(const QModelIndex &parent) const
     if (parent.isValid()) {
         return 0;
     }
-
-    return mRubyModel.send("count").to<int>();
+    int count;
+    withGvl([&] {
+        rescueNotify([&] {
+            count = NUM2INT(rb_funcall(mRubyModel, RUBYQML_INTERN("count"), 0));
+        });
+    });
+    return count;
 }
 
 QModelIndex ListModel::index(int row, int column, const QModelIndex &parent) const
@@ -84,6 +99,16 @@ void ListModel::endRemove()
     endRemoveRows();
 }
 
+void ListModel::beginReset()
+{
+    beginResetModel();
+}
+
+void ListModel::endReset()
+{
+    endResetModel();
+}
+
 void ListModel::update(int first, int last)
 {
     emit dataChanged(index(first), index(last));

data/ext/qml/listmodel.h

@@ -32,6 +32,8 @@ public slots:
     void endInsert();
     void beginRemove(int first, int last);
     void endRemove();
+    void beginReset();
+    void endReset();
     void update(int first, int last);
 
 private:

data/ext/qml/util.cpp

@@ -71,6 +71,13 @@ void rescue(const std::function<void ()> &doAction, const std::function<void (Ru
     rb_rescue((VALUE (*)(...))callback, (VALUE)&doAction, (VALUE (*)(...))rescueCallback, (VALUE)&handleException);
 }
 
+void rescueNotify(const std::function<void ()> &doAction)
+{
+    rescue(doAction, [&](RubyValue excObject) {
+        rb_funcall(rb_path2class("QML::Application"), rb_intern("notify_error"), 1, excObject);
+    });
+}
+
 namespace {
 
 void changeGvl(const std::function<void ()> &doAction, bool gvl)

data/ext/qml/util.h

@@ -77,6 +77,7 @@ protect(const F &doAction)
 void unprotect(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);
 
 // call function with GVL unlocked
 void withoutGvl(const std::function<void()> &doAction);

data/ext/qml/weakvaluereference.cpp

@@ -1,27 +1,52 @@
 #include "weakvaluereference.h"
+#include "ext_anywrapper.h"
 #include "rubyclass.h"
 
+Q_DECLARE_METATYPE(std::shared_ptr<RubyQml::WeakValueReference::Data>)
+
 namespace RubyQml {
 
+struct WeakValueReference::Data
+{
+    bool mHasValue;
+    RubyValue mValue;
+
+    static VALUE finalize(VALUE args, VALUE data) {
+        Q_UNUSED(args);
+        auto variant = wrapperRubyClass<Ext::AnyWrapper>().unwrap(data)->value();
+        auto sp = variant.value<std::shared_ptr<Data>>();
+        sp->invalidiate();
+        return Qnil;
+    }
+
+    void invalidiate()
+    {
+        mHasValue = false;
+        mValue = Qnil;
+    }
+};
+
 WeakValueReference::WeakValueReference(RubyValue value) :
-    mHasValue(true),
-    mValue(value)
+    d(std::make_shared<Data>())
 {
+    d->mHasValue = true;
+    d->mValue = value;
     static auto objspace = RubyModule::fromPath("ObjectSpace");
     protect([&] {
-        auto proc = rb_proc_new((VALUE (*)(...))&finalize, VALUE(this));
+        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);
     });
 }
 
-VALUE WeakValueReference::finalize(VALUE arg, VALUE data)
+bool WeakValueReference::hasValue() const
+{
+    return d->mHasValue;
+}
+
+RubyValue WeakValueReference::value() const
 {
-    Q_UNUSED(arg);
-    auto reference = (WeakValueReference *)data;
-    reference->mHasValue = false;
-    reference->mValue = Qnil;
-    return Qnil;
+    return d->mValue;
 }
 
 } // namespace RubyQml

data/ext/qml/weakvaluereference.h

@@ -1,5 +1,6 @@
 #pragma once
 #include "rubyvalue.h"
+#include <memory>
 
 namespace RubyQml {
 
@@ -8,12 +9,13 @@ class WeakValueReference
 public:
     WeakValueReference(RubyValue value);
 
-    bool hasValue() const { return mHasValue; }
-    RubyValue value() const { return mValue; }
+    bool hasValue() const;
+    RubyValue value() const;
+
+    struct Data;
+
 private:
-    static VALUE finalize(VALUE arg, VALUE data);
-    bool mHasValue;
-    RubyValue mValue;
+    std::shared_ptr<Data> d;
 };
 
 } // namespace RubyQml

data/lib/qml/class_builder.rb

@@ -33,6 +33,7 @@ module QML
       @objptr = objptr
       @metaobj = metaobj
       @name = name
+      @initialized = false
     end
 
     private

data/lib/qml/data.rb

@@ -1,2 +1,3 @@
 require 'qml/data/list_model'
 require 'qml/data/array_model'
+require 'qml/data/query_model'

data/lib/qml/data/array_model.rb

@@ -2,8 +2,10 @@ module QML
   module Data
     # {ArrayModel} is one of ruby-qml's list models and it stores data in Array simply.
     class ArrayModel < ListModel
-      def initialize
-        super()
+
+      # @param [Array<Symbol|String>] columns
+      def initialize(*columns)
+        super
         @array = []
       end
 
@@ -98,6 +100,25 @@ module QML
       def pop(count = nil)
         delete_at(@array.size - count, count)
       end
+
+      # Deletes all items.
+      # @return [self]
+      def clear
+        removing(0 ... count) do
+          @array.clear
+        end
+        self
+      end
+
+      # Replaces entire array with given array.
+      # @param [Array] ary
+      # @return [self]
+      def replace(ary)
+        resetting do
+          @array = ary.dup
+        end
+        self
+      end
     end
   end
 end