qml 0.0.1

data/lib/qml/qt_classes.rb

@@ -0,0 +1,9 @@
+require 'qml/plugins'
+
+module QML
+  Application = Kernel.application_meta_object.build_class
+  Engine = Kernel.engine_meta_object.build_class
+  Context = Plugins.core.metaObjects['QQmlContext'].build_class
+  Component = Plugins.core.metaObjects['QQmlComponent'].build_class
+  Qt = Plugins.core.metaObjects['Qt'].build_class
+end

data/lib/qml/qt_object_base.rb

@@ -0,0 +1,108 @@
+require 'qml/dispatchable'
+
+module QML
+
+  # {QtObjectBase} is the base class for Qt object wrappers.
+  #
+  # In ruby-qml you can access the followings of Qt objects in Ruby.
+  #
+  # * Properties as {Reactive::Property}
+  # * Signals as {Reactive::Signal}
+  # * Q_INVOKABLE methods, slots and QML methods as Ruby methods
+  #
+  # Properties and signals support is provided by {Reactive::Object}.
+  #
+  # While their names are camelCase in Qt, ruby-qml aliases them as underscore_case.
+  #
+  # @example
+  #   # QML::Application is actually a wrapper for QApplication
+  #   app = QML.application
+  #
+  #   # set property
+  #   app.applicationName = "Test"
+  #   app.application_name = "Test" # aliased version
+  #
+  #   # connect to signal
+  #   app.aboutToQuit.connect do # "about_to_quit" is also OK
+  #     puts "quitting..."
+  #   end
+  #
+  #   # call slot
+  #   app.quit
+  class QtObjectBase
+    include Dispatchable
+    include Reactive::Object
+
+    class << self
+      attr_accessor :meta_object
+      private :meta_object=
+    end
+
+    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
+    # @return the result.
+    # @example
+    #   component = QML::Component.new data: <<-EOS
+    #     import QtQuick 2.0
+    #     QtObject {
+    #       property string foo: 'foo'
+    #       property string bar: 'bar'
+    #     }
+    #   EOS
+    #   obj = component.create
+    #   obj.qml_eval("foo + bar") #=> "foobar"
+    def qml_eval(str)
+      context = Context.for_object(self)
+      fail QMLError, 'belongs to no context' unless context
+      context.eval(self, str)
+    end
+
+    def inspect
+      klass = self.class
+      property_inspect = klass.instance_properties.sort
+        .reject { |name| klass.instance_property(name).alias? }
+        .map do |name|
+          "#{name}=" +
+            begin
+              property(name).value.inspect
+            rescue ConversionError
+              "<unsupported type>"
+            end
+        end
+        .join(' ')
+      classname = klass.name || "[class for #{klass.meta_object.name}]"
+      "#<#{classname}:#{__id__} #{property_inspect}>"
+    end
+
+    alias_method :to_s, :inspect
+
+    # @return whether the object is managed by Ruby and QML and garbage collected when no longer used.
+    def managed?
+      pointer.managed?
+    end
+
+    # Sets the management status of the object.
+    # @param [Boolean] managed
+    # @return [Boolean]
+    def managed=(managed)
+      pointer.managed = managed
+    end
+
+    # Sets the management status of the object in safer way.
+    # Objects that are created by QML will remain managed and objects that have parents will remain unmanaged.
+    # @param [Boolean] managed
+    # @return [Boolean]
+    def prefer_managed(managed)
+      pointer.prefer_managed managed
+    end
+  end
+end

data/lib/qml/reactive.rb

@@ -0,0 +1,8 @@
+require 'qml/reactive/signal'
+require 'qml/reactive/signals/map_signal'
+require 'qml/reactive/signals/select_signal'
+require 'qml/reactive/signals/merge_signal'
+require 'qml/reactive/signal_spy'
+require 'qml/reactive/property'
+require 'qml/reactive/object'
+require 'qml/reactive/error'

data/lib/qml/reactive/bindable.rb

@@ -0,0 +1,79 @@
+module QML
+  module Reactive
+    module Bindable
+
+      def initialize(*args, &block)
+        super
+        @connections = []
+      end
+
+      # Sets a new value.
+      # The old property binding is discarded.
+      # @param new_value new value 
+      def value=(new_value, unbind = true)
+        self.unbind if unbind
+        unless value == new_value
+          super(new_value)
+          changed.emit(new_value)
+        end
+        new_value
+      end
+
+      alias_method :set_value, :value=
+
+      # @return The property value
+      def value
+        touch
+        super
+      end
+
+      # @api private
+      module Resolver
+        @sources_stack = []
+        class << self
+          def eval_and_resolve(&block)
+            @sources_stack.push([])
+            ret = block.call
+            [ret, @sources_stack.pop]
+          end
+
+          def add(property)
+            current = @sources_stack.last
+            current && current << property
+          end
+        end
+      end
+
+      # Sets a property binding.
+      # The block is re-evaluated when any of other properties used in it is updated
+      # and the result is used as the new property value.
+      # @yield
+      # @example
+      #    p1 = Property.new
+      #    p2 = Property.new
+      #    p1.bind { p2.value + 1 }
+      #    p2.value = 10
+      #    p1.value #=> 11
+      # @return The property value
+      def bind(&block)
+        unbind
+        value, sources = Resolver.eval_and_resolve(&block)
+        set_value(value, false)
+        @connections = sources.map do |source|
+          fail Error, 'Recursive binding' if source == self
+          source.changed.connect { set_value(block.call, false) }
+        end
+      end
+
+      def unbind
+        @connections.each(&:disconnect)
+      end
+
+      private
+
+      def touch
+        Resolver.add(self)
+      end
+    end
+  end
+end

data/lib/qml/reactive/chained_signal.rb

@@ -0,0 +1,25 @@
+require 'qml/reactive/signal'
+
+module QML
+  module Reactive
+    class ChainedSignal < Signal
+      private
+      def connected(listener)
+        if connection_count == 1
+          @connections = Array(connect_to_sources)
+        end
+      end
+
+      def disconnected(listener)
+        if connection_count == 0
+          @connections.each(&:disconnect)
+          @connections = nil
+        end
+      end
+
+      def connect_to_sources
+        fail NotImplementedError
+      end
+    end
+  end
+end

data/lib/qml/reactive/error.rb

@@ -0,0 +1,5 @@
+module QML
+  module Reactive
+    class Error < ::StandardError; end
+  end
+end

data/lib/qml/reactive/object.rb

@@ -0,0 +1,278 @@
+require 'qml/reactive/unbound_signal'
+require 'qml/reactive/unbound_property'
+
+module QML
+  module Reactive
+
+    # {Object} is used to define signals and properties within class definition.
+    # Signals and properties will be inherited by and can be overridden in subclasses.
+    # @note Currently {Object} can be included only by classes, not modules.
+    # @see Object::ClassMethods
+    module Object
+
+      # When {Object} is included by a class, the class extends {ClassMethods} to add the common class methods.
+      def self.included(derived)
+        fail Error, "SignalDef must be included in a class" unless derived.is_a? ::Class
+        derived.extend(ClassMethods)
+      end
+
+      def initialize(*args, &block)
+        super
+        properties = self.class.instance_property_hash
+          .values
+          .map { |property| self.class.instance_property(property.original) }
+          .uniq
+        notifier_signals = properties.map(&:notifier_signal)
+        signals = self.class.instance_signal_hash
+          .values
+          .map { |signal| self.class.instance_signal(signal.original) }
+          .uniq - notifier_signals
+
+        properties.each do |property|
+          p = property.bind(self)
+          instance_variable_set(:"@_property_#{property.name}", p)
+          instance_variable_set(:"@_signal_#{property.notifier_signal.name}", p.changed)
+        end
+        signals.each do |signal|
+          instance_variable_set(:"@_signal_#{signal.name}", signal.bind(self))
+        end
+
+        self.class.send(:initial_connections_hash).each do |name, blocks|
+          blocks.each do |block|
+            signal(name).connect do |*args|
+              instance_exec(*args, &block)
+            end
+          end
+        end
+      end
+
+      # @!method signal(name)
+      #   Returns a signal.
+      #   @param name [Symbol] The signal name
+      #   @return [QML::Reactive::Signal]
+
+      # @!method signals
+      #   Returns all signal names.
+      #   @return [Array<Symbol>]
+
+      # @!method property(name)
+      #   Returns a property.
+      #   @param name [Symbol] The property name
+      #   @return [QML::Reactive::Property]
+
+      # @!method properties
+      #   Returns all property names.
+      #   @return [Array<Symbol>]
+
+      [%w{signal signals}, %w{property properties}].each do |singular, plural|
+        class_eval <<-EOS, __FILE__, __LINE__ + 1
+          def #{singular}(name)
+            name = self.class.instance_#{singular}(name).original
+            instance_variable_get(:"@_#{singular}_\#{name}") or
+              fail ::NameError, "undefined #{singular} '\#{name}' for class '\#{self.class}'"
+          end
+
+          def #{plural}
+            self.class.instance_#{plural}
+          end
+        EOS
+      end
+
+      # @!parse extend ClassMethods
+
+      module ClassMethods
+
+        # @!method instance_signals(include_super = true)
+        #   Returns all signal names for the class.
+        #   @param include_super [true|false]
+        #   @return [Array<Symbol>]
+
+        # @!method instance_signal(name)
+        #   Returns an unbound signal.
+        #   @param name [Symbol] The signal name
+        #   @return [QML::Reactive::UnboundSignal]
+
+        # @!method instance_properties(include_super = true)
+        #   Returns all property names for the class.
+        #   @param include_super [true|false]
+        #   @return [Array<Symbol>]
+
+        # @!method instance_property(name)
+        #   Returns an unbound property.
+        #   @param name [Symbol] The property name
+        #   @return [QML::Reactive::UnboundProperty]
+        [%w{signal signals}, %w{property properties}].each do |singular, plural|
+          class_eval <<-EOS, __FILE__, __LINE__ + 1
+            def instance_#{singular}_hash(include_super = true)
+              if include_super && superclass.include?(Object)
+                superclass.instance_#{singular}_hash.merge instance_#{singular}_hash(false)
+              else
+                @instance_#{singular}_hash ||= {}
+              end
+            end
+
+            def instance_#{plural}(include_super = true)
+              instance_#{singular}_hash(include_super).keys
+            end
+
+            def instance_#{singular}(name)
+              instance_#{singular}_hash[name] or fail ::NameError, "undefined #{singular} '\#{name}' for class '\#{self}'"
+            end
+          EOS
+        end
+
+        # Defines a signal for the class.
+        # The signal will be variadic if args == nil.
+        # @param name [#to_sym] The signal name
+        # @param params [Array<#to_sym>, nil] The signal parameter names
+        # @return [Symbol] The signal name
+        # @example
+        #   class Button
+        #     include QML::Reactive::Object
+        #     signal :pressed, [:pos]
+        #     def press(pos)
+        #       pressed.emit(pos)
+        #     end
+        #   end
+        #
+        #   button = Button.new
+        #   button.pressed.connect { |pos| puts "Pressed at #{pos}" }
+        #   button.press([10, 20])
+        #
+        #   class ColorButton < Button
+        #     signal :pressed, [:pos, :color]
+        #   end
+        #
+        #   color_button = ColorButton.new
+        #   color_button.pressed.connect { |pos, color| "#{color} button pressed at #{pos}" }
+        #   color_button.press([10, 20], 'red')
+        def signal(name, params, factory: nil)
+          name.to_sym.tap do |name|
+            params = params.map(&:to_sym)
+            add_signal(UnboundSignal.new(name, params, false, self, factory))
+          end
+        end
+
+        # Defines a variadic signal.
+        # Variadic signals do not restrict the number of arguments.
+        # @see #signal
+        def variadic_signal(name, factory: nil)
+          name.to_sym.tap do |name|
+            add_signal(UnboundSignal.new(name, nil, true, self, factory))
+          end
+        end
+
+        # Aliases a signal.
+        # @return [Symbol] The new name
+        def alias_signal(name, original_name)
+          add_signal(instance_signal(original_name).alias(name))
+          name
+        end
+
+        # Defines a property for the class.
+        # @param name [#to_sym] The name of the property
+        # @param init_value The initial value (optional)
+        # @yield The initial property binding (optional)
+        # @return [Symbol] The name
+        # @example
+        #   class Foo
+        #     include QML::Reactive::Object
+        #     property(:name) { 'hogehoge' }
+        #     ...
+        #   end
+        #   Foo.new.name #=> 'hogehoge'
+        #   Foo.new.name = 'foobar'
+        #   Foo.new.name #=> 'foobar'
+        #   Foo.new.name_changed.connect do |new_name|
+        #     ...
+        #
+        #   class Bar < Foo
+        #     property(:name) { 'piyopiyo' }
+        #   end
+        #   Bar.new.name #=> 'piyopiyo'
+        def property(name, init_value = nil, factory: nil, &init_binding)
+          name = name.to_sym
+          add_property(UnboundProperty.new(name, init_value, init_binding, self, factory))
+          name
+        end
+
+        # Aliases a property.
+        # @return [Symbol] The new name
+        def alias_property(name, original_name)
+          add_property(instance_property(original_name).alias(name))
+          name
+        end
+
+        # Adds a signal handler.
+        # @param signal_name The name of the signal
+        # @yield The block that is connected to the signal during object initialization
+        def on(signal_name, &block)
+          # just for check
+          instance_signal(signal_name)
+          @initial_connections_hash ||= {}
+          @initial_connections_hash[signal_name] ||= []
+          @initial_connections_hash[signal_name] << block
+        end
+
+        # Adds a handler to a property change signal.
+        # @param property_name The name of the property
+        # @yield The block that is connected to the property change signal during object initialization
+        # @example
+        #   class Foo
+        #     property :bar, ''
+        #     on_changed :bar do
+        #       some_action
+        #     end
+        #     def some_action
+        #       ...
+        #     end
+        #   end
+        # @see #on
+        def on_changed(property_name, &block)
+          on(:"#{property_name}_changed", &block)
+        end
+
+        private
+
+        def add_signal(signal)
+          instance_signal_hash(false)[signal.name] = signal
+
+          class_eval <<-EOS, __FILE__, __LINE__ + 1
+            def #{signal.name}
+              @_signal_#{signal.original}
+            end
+          EOS
+        end
+
+        def add_property(property)
+          instance_property_hash(false)[property.name] = property
+
+          class_eval <<-EOS, __FILE__, __LINE__ + 1
+            def #{property.name}(&block)
+              @_property_#{property.original}.value(&block)
+            end
+            def #{property.name}=(new_value)
+              @_property_#{property.original}.value = new_value
+            end
+          EOS
+
+          add_signal(property.notifier_signal)
+        end
+
+        def initial_connections_hash(include_super: true)
+          if include_super && superclass.include?(Object)
+            superclass.send(:initial_connections_hash).dup.tap do |hash|
+              initial_connections_hash(include_super: false).each do |key, blocks|
+                hash[key] ||= []
+                hash[key] += blocks
+              end
+            end
+          else
+            @initial_connections_hash ||= {}
+          end
+        end
+      end
+    end
+  end
+end
+