qml 0.0.1

data/ext/qml/util.h

@@ -0,0 +1,101 @@
+#pragma once
+
+#include <QMetaType>
+#include <functional>
+#include <type_traits>
+#include <array>
+#include <ruby.h>
+
+#ifndef RARRAY_AREF
+#define RARRAY_AREF(a, i)    ((RARRAY_PTR(a)[i]))
+#endif
+
+namespace RubyQml {
+
+template <size_t... Indices>
+struct IntegerSequence {};
+
+template <size_t N, typename Seq = IntegerSequence<>, bool Last = N == 0>
+struct MakeIntegerSequenceImpl
+{
+    using type = Seq;
+};
+
+template <size_t N, size_t... Indices>
+struct MakeIntegerSequenceImpl<N, IntegerSequence<Indices...>, false> :
+        MakeIntegerSequenceImpl<N - 1, IntegerSequence<N - 1, Indices...>>
+{};
+
+template <size_t N>
+using MakeIntegerSequence = typename MakeIntegerSequenceImpl<N>::type;
+
+template <typename F, typename... Args, size_t... Indices>
+typename std::result_of<F(Args...)>::type
+applyWithTupleImpl(const F &func, const std::tuple<Args...> &args, IntegerSequence<Indices...>)
+{
+    return func(std::get<Indices>(args)...);
+}
+
+template <typename F, typename... Args>
+typename std::result_of<F(Args...)>::type
+applyWithTuple(const F &func, const std::tuple<Args...> &args)
+{
+    return applyWithTupleImpl(func, args, MakeIntegerSequence<sizeof...(Args)>());
+}
+
+class RubyValue;
+
+class RubyException
+{
+public:
+    RubyException(int state) : mState(state) {}
+    int state() const { return mState; }
+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 rescue(const std::function<void ()> &doAction, const std::function<void (RubyValue)> &handleException);
+
+// call function with GVL unlocked
+void withoutGvl(const std::function<void()> &doAction);
+
+// call function with GVL locked
+void withGvl(const std::function<void()> &doAction);
+
+void fail(const char *errorClassName, const QString &message);
+
+template <typename ... TArgs>
+void callSuper(TArgs ... args)
+{
+    constexpr int argc = sizeof...(args);
+    std::array<VALUE, argc> argv = {{ VALUE(args)... }};
+    protect([&] {
+        rb_call_super(argc, argv.data());
+    });
+}
+
+} // namespace RubyQml
+
+Q_DECLARE_METATYPE(const QMetaObject*)

data/ext/qml/valuereference.cpp

@@ -0,0 +1,50 @@
+#include "valuereference.h"
+#include <QSet>
+
+namespace RubyQml {
+
+using ReferenceCounts = QHash<RubyValue, int>;
+Q_GLOBAL_STATIC(ReferenceCounts, referenceCounts)
+
+struct ValueReference::Owner
+{
+    Owner(RubyValue value) :
+        value(value)
+    {
+        auto &refCounts = *referenceCounts;
+        if (!refCounts.contains(value)) {
+            refCounts[value] = 0;
+        }
+        refCounts[value] += 1;
+    }
+    ~Owner()
+    {
+        auto &refCounts = *referenceCounts;
+        refCounts[value] -= 1;
+        if (refCounts[value] == 0) {
+            refCounts.remove(value);
+        }
+    }
+    RubyValue value;
+};
+
+ValueReference::ValueReference(RubyValue value) :
+    mOwner(makeSP<Owner>(value))
+{
+}
+
+RubyValue ValueReference::value() const
+{
+    return mOwner->value;
+}
+
+void ValueReference::markAllReferences()
+{
+    auto begin = referenceCounts->begin();
+    auto end = referenceCounts->end();
+    for (auto i = begin; i != end; ++i) {
+        rb_gc_mark(i.key());
+    }
+}
+
+} // namespace RubyQml

data/ext/qml/valuereference.h

@@ -0,0 +1,22 @@
+#pragma once
+#include "rubyvalue.h"
+#include "common.h"
+
+namespace RubyQml {
+
+class ValueReference
+{
+public:
+    ValueReference() = default;
+    ValueReference(RubyValue value);
+
+    RubyValue value() const;
+
+    static void markAllReferences();
+
+private:
+    struct Owner;
+    SP<Owner> mOwner;
+};
+
+} // namespace RubyQml

data/ext/qml/weakvaluereference.cpp

@@ -0,0 +1,27 @@
+#include "weakvaluereference.h"
+#include "rubyclass.h"
+
+namespace RubyQml {
+
+WeakValueReference::WeakValueReference(RubyValue value) :
+    mHasValue(true),
+    mValue(value)
+{
+    static auto objspace = RubyModule::fromPath("ObjectSpace");
+    protect([&] {
+        auto proc = rb_proc_new((VALUE (*)(...))&finalize, VALUE(this));
+        VALUE args[] = { value };
+        rb_funcall_with_block(objspace, RUBYQML_INTERN("define_finalizer"), 1, args, proc);
+    });
+}
+
+VALUE WeakValueReference::finalize(VALUE arg, VALUE data)
+{
+    Q_UNUSED(arg);
+    auto reference = (WeakValueReference *)data;
+    reference->mHasValue = false;
+    reference->mValue = Qnil;
+    return Qnil;
+}
+
+} // namespace RubyQml

data/ext/qml/weakvaluereference.h

@@ -0,0 +1,19 @@
+#pragma once
+#include "rubyvalue.h"
+
+namespace RubyQml {
+
+class WeakValueReference
+{
+public:
+    WeakValueReference(RubyValue value);
+
+    bool hasValue() const { return mHasValue; }
+    RubyValue value() const { return mValue; }
+private:
+    static VALUE finalize(VALUE arg, VALUE data);
+    bool mHasValue;
+    RubyValue mValue;
+};
+
+} // namespace RubyQml

data/lib/qml.rb

@@ -0,0 +1,41 @@
+require 'qml/version'
+require 'qml/qml'
+
+require 'qml/geometry'
+require 'qml/reactive'
+
+require 'qml/meta_object'
+require 'qml/plugin_loader'
+require 'qml/component'
+require 'qml/engine'
+require 'qml/context'
+require 'qml/application'
+require 'qml/image_provider'
+require 'qml/qt'
+require 'qml/access'
+require 'qml/root_path'
+require 'qml/dispatcher'
+require 'qml/dispatchable'
+
+require 'qml/data'
+require 'qml/test_util'
+
+module QML
+
+  def initialized?
+    Kernel.initialized?
+  end
+
+  # Initializes ruby-qml.
+  # @param [Boolean] offscreen set this to true to run application offscreen (without GUI)
+  def init(offscreen: false)
+    fail AlreadyInitializedError, "ruby-qml already initialized" if initialized?
+    argv = [$PROGRAM_NAME]
+    argv += %w{-platform offscreen} if offscreen
+    Kernel.init(argv)
+    application.events_processed.each do
+      Dispatcher.instance.run_tasks
+    end
+  end
+  module_function :initialized?, :init
+end

data/lib/qml/access.rb

@@ -0,0 +1,137 @@
+require 'ostruct'
+require 'qml/qml'
+require 'qml/dispatchable'
+require 'qml/wrappable'
+
+module QML
+
+  # {Access} enables classes to be exposed to QML.
+  #
+  module Access
+    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
+
+    # @api private
+    def self.unregistered_classes
+      @unregistered_classes ||= []
+    end
+
+    # @api private
+    def self.register_classes
+      unregistered_classes.each(&:register_to_qml_real)
+    end
+
+    # allowed name patterns for exposed method names
+    ALLOWED_PATTERN = /^[a-zA-Z_]\w*$/
+
+    module ClassMethods
+
+      # Registers the class as a QML type.
+      # @param under [String|nil] the namespece which encapsulates the exported QML type. If not specified, automatically inferred from the module nesting of the class.
+      # @param version [String|nil] the version of the type. Defaults to VERSION constant of the encapsulating module / class of the class.
+      # @param name [String|nil] the name of the type. Defaults to the name of the class.
+      def register_to_qml(under: nil, version: nil, name: nil)
+        if !under || !version || !name
+          path = self.name.split('::')
+        end
+        if !under && !version
+          fail AccessError, "cannot guess namespace of toplevel class '#{self.name}'" if path.size == 1
+          encapsulatings = path[0, path.size - 1]
+        end
+
+        under ||= encapsulatings.join('.')
+        version ||= eval("::#{encapsulatings.join('::')}").const_get(:VERSION)
+        versions = version.split('.').map(&method(:Integer))
+        fail AccessError, 'insufficient version (major and minor versions required)' unless versions.size >= 2
+        name ||= path.last
+
+        @qml_registeration = {
+          under: under,
+          version_major: versions[0],
+          version_minor: versions[1],
+          name: name
+        }
+        Access.unregistered_classes << self
+      end
+
+      # @api private
+      def register_to_qml_real
+        access_wrapper_factory.register_to_qml(
+          @qml_registeration[:under],
+          @qml_registeration[:version_major],
+          @qml_registeration[:version_minor],
+          @qml_registeration[:name])
+      end
+
+      # @api private
+      def access_wrapper_factory
+        @access_wrapper_factory ||= create_access_wrapper_factory
+      end
+
+      private
+
+      def create_access_wrapper_factory
+        classname = "RubyQml::Access::#{name}"
+
+        signals = instance_signals.grep(ALLOWED_PATTERN)
+        properties = instance_properties.grep(ALLOWED_PATTERN)
+
+        signal_infos = signals
+          .map { |name| instance_signal(name) }
+          .reject(&:variadic?)
+          .map { |signal| OpenStruct.new(name: signal.name, params: signal.parameters.map(&:last)) }
+
+        property_infos = properties
+          .map { |name| OpenStruct.new(name: name, getter: name, setter: :"#{name}=", notifier: :"#{name}_changed") }
+
+        methods = ancestors.take_while { |k| k.include?(Access) }
+          .map { |k| k.instance_methods(false) }.inject(&:|)
+          .grep(ALLOWED_PATTERN)
+        ignored_methods = signals | property_infos.flat_map { |p| [p.getter, p.setter, p.notifier] }
+        method_infos = (methods - ignored_methods)
+          .map { |name| instance_method(name) }
+          .select { |method| method.parameters.all? { |param| param[0] == :req } }
+          .map { |method| OpenStruct.new(name: method.name, params: method.parameters.map(&:last)) }
+
+        AccessWrapperFactory.new(self, classname, method_infos, signal_infos, property_infos)
+      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
+      @access_wrappers = []
+    end
+
+    def create_wrapper
+      self.class.access_wrapper_factory.create(self)
+    end
+  end
+end

data/lib/qml/application.rb

@@ -0,0 +1,139 @@
+require 'qml/qt_classes'
+
+module QML
+  # @!parse class Application < QtObjectBase; end
+
+  # {Application} represents a Qt application instance.
+  # It provides the event loop and manages Application-level configurations.
+  #
+  # @see http://qt-project.org/doc/qt-5/qapplication.html QApplication (C++)
+  class Application
+
+    # @return [Application] The application instance.
+    def self.instance
+      Kernel.application
+    end
+
+    def self.notify_error(error)
+      instance.notify_error(error)
+    end
+
+    # @note This method cannot be called because {Application} is singleton. 
+    def self.new
+      fail ApplicationError, "cannot create Application instance manually"
+    end
+
+    # @!method events_processed
+    # This signal is emitted every time events are processed in the event loop.
+    # @return [Reactive::Signal]
+    signal :events_processed, []
+
+    def initialize
+      super()
+      @extension = Plugins.core.createApplicationExtension(self)
+      @extension.events_processed.each do
+        events_processed.call
+      end
+    end
+
+    # @return [Engine] The engine of the application.
+    def engine
+      Kernel.engine
+    end
+
+    # @return [Context] The root context of the engine.
+    # @see #engine
+    def context
+      engine.context
+    end
+
+    # @return [Component] The root component of the application that represents the loaded QML file.
+    # @see #load
+    # @see #load_data
+    # @see #load_path
+    def root_component
+      @root_component or fail ApplicationError, "QML data or file has not been loaded"
+    end
+
+    # Loads a QML file. The loaded component can be accessed by {#root_component}
+    # @see Component
+    def load(data: nil, path: nil)
+      @root_component = Component.new(data: data, path: path)
+      @root = @root_component.create
+    end
+
+    # Loads a QML file from string data.
+    # @see #load
+    def load_data(data)
+      load(data: data)
+    end
+
+    # Loads a QML file from a file path.
+    # @see #load
+    def load_path(path)
+      load(path: path)
+    end
+
+    # @return The root object created by the root component.
+    def root
+      @root or fail "QML data or file has not been loaded"
+    end
+
+    # Starts the event loop of the application.
+    # This method never returns until the application quits.
+    def exec
+      @extension.exec
+    end
+
+    # Processes queued events in the event loop manually.
+    # This method is useful when you are combining an external event loop like EventMachine.
+    def process_events
+      @extension.process_events
+    end
+
+    def force_deferred_deletes
+      @extension.force_deferred_deletes
+    end
+
+    # Runs garbage collection of Ruby and QML and deletes unused objects.
+    def collect_garbage
+      ::GC.start
+      engine.collect_garbage
+      force_deferred_deletes
+    end
+
+    # Called when an Ruby error is occured in executing Qt code.
+    # @param error The error (or the exception)
+    def notify_error(error)
+      warn "-- An error occured when running Ruby code from Qt --"
+      warn "#{error.class.name}: #{error.message}"
+      warn "Backtrace: \n\t#{error.backtrace.join("\n\t")}"
+    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
+  def application
+    if block_given?
+      QML.init unless QML.initialized?
+      Application.instance.tap do |app|
+        yield app
+        app.exec
+      end
+    else
+      Application.instance
+    end
+  end
+
+  module_function :application
+end