qml 0.0.1

data/lib/qml/reactive/property.rb

@@ -0,0 +1,19 @@
+require 'qml/reactive/error'
+require 'qml/reactive/simple_property'
+require 'qml/reactive/bindable'
+
+module QML
+  module Reactive
+    class Property < SimpleProperty
+      include Bindable
+
+      # @param initial_value the initial value.
+      # @yield the initial property binding (optional).
+      def initialize(initial_value = nil, &block)
+        super()
+        self.value = initial_value if initial_value
+        bind(&block) if block
+      end
+    end
+  end
+end

data/lib/qml/reactive/signal.rb

@@ -0,0 +1,116 @@
+module QML
+  module Reactive
+
+    class Signal
+
+      class Connection
+        def initialize(signal, listener)
+          @signal = signal
+          @listener = listener
+        end
+
+        # Disconnects the connection.
+        def disconnect
+          @signal.disconnect(@listener)
+        end
+      end
+
+      attr_reader :arity
+
+      # Initializes the Signal.
+      # The signal will be variadic if an empty array is given.
+      # @param [Array<#to_sym>, Array<()>] params The parameter names.
+      def initialize(*params, variadic: false)
+        @listeners = []
+        if variadic
+          @params = nil
+          @arity = -1
+        else
+          @params = params.map(&:to_sym)
+          @arity = params.size
+        end
+      end
+
+      # Calls every connected procedure with given arguments.
+      # Raises an ArgumentError when the arity is wrong.
+      # @param args the arguments.
+      def emit(*args)
+        if @arity >= 0 && args.size != @arity
+          fail ::ArgumentError ,"wrong number of arguments for signal (#{args.size} for #{@arity})"
+        end
+        @listeners.each do |listener|
+          listener.call(*args)
+        end
+      end
+
+      alias_method :call, :emit
+      alias_method :[], :emit
+
+      # Returns the format of the parameters in the same format as Proc#parameters.
+      # @return [Array<Array<Symbol>>]
+      def parameters
+        @params ? @params.map { |arg| [:req, arg] } : [[:rest, :args]]
+      end
+
+      # Converts the signal into a Proc.
+      # @return [Proc]
+      def to_proc
+        method(:emit).to_proc
+      end
+
+      # Returns the number of connections.
+      # @return [Integer]
+      def connection_count
+        @listeners.size
+      end
+
+      # Connects a procedure.
+      # @yield called when #emit is called.
+      # @return [QML::Reactive::Signal::Connection]
+      def connect(&listener)
+        @listeners << listener
+        connected(listener)
+        Connection.new(self, listener)
+      end
+
+      alias_method :each, :connect
+
+      # Disconnects a procedure.
+      # @param listener
+      # @return [self]
+      def disconnect(listener)
+        @listeners.delete(listener)
+        disconnected(listener)
+        self
+      end
+
+      # Creates a transformed version of the signal.
+      # @return [QML::Reactive::Signal]
+      def map(&block)
+        Signals::MapSignal.new(self, block)
+      end
+
+      alias_method :collect, :map
+
+      # Creates a filtered version of the signal.
+      # @return [QML::Reactive::Signal]
+      def select(&block)
+        Signals::SelectSignal.new(self, block)
+      end
+
+      # Creates a merged signal.
+      # @return [QML::Reactive::Signal]
+      def merge(*others)
+        Signals::MergeSignal.new([self] + others)
+      end
+
+      private
+
+        def connected(listener)
+        end
+    
+        def disconnected(listener)
+        end
+    end
+  end
+end

data/lib/qml/reactive/signal_spy.rb

@@ -0,0 +1,27 @@
+module QML
+  module Reactive
+
+    class Signal
+      def spy
+        SignalSpy.new(self)
+      end
+    end
+
+    class SignalSpy
+
+      attr_reader :args
+
+      def initialize(signal)
+        @args = []
+        signal.connect(&method(:on_emitted))
+      end
+
+      private
+
+        def on_emitted(*args)
+          @args << args
+        end
+    end
+
+  end
+end

data/lib/qml/reactive/signals/map_signal.rb

@@ -0,0 +1,21 @@
+require 'qml/reactive/chained_signal'
+
+module QML
+  module Reactive
+    module Signals
+      class MapSignal < ChainedSignal
+        def initialize(source, func)
+          super(:mapped)
+          @source = source
+          @func = func
+        end
+
+        def connect_to_sources
+          @source.connect do |*args|
+            emit(@func[*args])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/qml/reactive/signals/merge_signal.rb

@@ -0,0 +1,21 @@
+require 'qml/reactive/chained_signal'
+
+module QML
+  module Reactive
+    module Signals
+      class MergeSignal < ChainedSignal
+        def initialize(sources)
+          param_count = sources.map(&:arity).max
+          super(*param_count.times.map { |i| :"arg#{i}" })
+          @sources = sources
+        end
+
+        def connect_to_sources
+          @sources.each do |source|
+            source.connect(&method(:emit))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/qml/reactive/signals/select_signal.rb

@@ -0,0 +1,21 @@
+require 'qml/reactive/chained_signal'
+
+module QML
+  module Reactive
+    module Signals
+      class SelectSignal < ChainedSignal
+        def initialize(source, pred)
+          super(*source.parameters.map(&:last))
+          @source = source
+          @pred = pred
+        end
+
+        def connect_to_sources
+          @source.connect do |*args|
+            emit(*args) if @pred.call(*args)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/qml/reactive/simple_property.rb

@@ -0,0 +1,17 @@
+require 'qml/reactive/signal'
+
+module QML
+  module Reactive
+    class SimpleProperty
+      attr_accessor :value
+
+      # @!attribute [r] changed
+      #   @return [QML::Reactive::Signal] The notification signal that is emitted when the value is changed
+      attr_reader :changed
+
+      def initialize
+        @changed = Signal.new(:new_value)
+      end
+    end
+  end
+end

data/lib/qml/reactive/unbound_property.rb

@@ -0,0 +1,42 @@
+require 'qml/reactive/property'
+require 'qml/reactive/unbound_signal'
+
+module QML
+  module Reactive
+    class UnboundProperty
+      attr_reader :name, :initial_value, :initial_binding, :owner, :notifier_signal, :original
+
+      def initialize(name, initial_value, initial_binding, owner, factory = nil)
+        @name = name
+        @initial_value = initial_value
+        @initial_binding = initial_binding
+        @owner = owner
+        @notifier_signal = UnboundSignal.new(:"#{name}_changed", [:new_value], false, owner)
+        @factory = factory
+        @original = name
+      end
+
+      def alias(name)
+        notifier_signal_orig = @notifier_signal
+        dup.tap do |property|
+          property.instance_eval do
+            @name = name
+            @notifier_signal = notifier_signal_orig.alias(:"#{name}_changed")
+          end
+        end
+      end
+
+      def alias?
+        @original != @name
+      end
+
+      def bind(obj)
+        return @factory.call(obj, self) if @factory
+        Property.new.tap do |p|
+          p.value = @initial_value if @initial_value
+          p.bind { obj.instance_eval &@initial_binding } if @initial_binding
+        end
+      end
+    end
+  end
+end

data/lib/qml/reactive/unbound_signal.rb

@@ -0,0 +1,51 @@
+require 'qml/reactive/signal'
+
+module QML
+  module Reactive
+    class UnboundSignal
+      attr_reader :name, :owner, :original
+
+      def initialize(name, params, variadic, owner, factory = nil)
+        @name = name
+        @params = params
+        @variadic = variadic
+        @owner = owner
+        @factory = factory
+        @original = name
+      end
+
+      def alias(name)
+        dup.tap do |signal|
+          signal.instance_eval do
+            @name = name
+          end
+        end
+      end
+
+      def variadic?
+        @variadic
+      end
+
+      def alias?
+        @original != @name
+      end
+
+      def arity
+        @params ? @params.size : -1
+      end
+
+      def parameters
+        @params ? @params.map { |arg| [:req, arg] } : [[:rest, :args]]
+      end
+
+      def bind(obj)
+        return @factory.call(obj, self) if @factory
+        if @variadic
+          Signal.new(variadic: true)
+        else
+          Signal.new(*@params)
+        end
+      end
+    end
+  end
+end

data/lib/qml/root_path.rb

@@ -0,0 +1,3 @@
+module QML
+  ROOT_PATH = Pathname.new(__FILE__) + '../../..'
+end

data/lib/qml/test_util.rb

@@ -0,0 +1 @@
+require 'qml/test_util/object_life_checker'

data/lib/qml/test_util/object_life_checker.rb

@@ -0,0 +1,17 @@
+require 'qml/plugins'
+
+module QML
+  module TestUtil
+
+    ObjectLifeChecker = Plugins.test_util.meta_objects['RubyQml::ObjectLifeChecker'].build_class
+
+    class ObjectLifeChecker
+
+      def self.new(obj)
+        Plugins.test_util.create_object_life_checker(obj)
+      end
+      alias_method :alive?, :is_alive
+      alias_method :owned_by_qml?, :is_owned_by_qml
+    end
+  end
+end

data/lib/qml/version.rb

@@ -0,0 +1,3 @@
+module QML
+  VERSION = "0.0.1"
+end

data/lib/qml/wrappable.rb

@@ -0,0 +1,9 @@
+module QML
+  module Wrappable
+    # @abstract
+    # @return [QtObjectBase] The created wrapper Qt Object
+    def create_wrapper
+      fail ::NotImplementedError
+    end
+  end
+end

data/qml.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'qml/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "qml"
+  spec.version       = QML::VERSION
+  spec.authors       = ["Ryohei Ikegami"]
+  spec.email         = ["iofg2100@gmail.com"]
+  spec.summary       = %q{A QML / Qt Quick wrapper for Ruby}
+  spec.description   = "ruby-qml provides bindings between QML and Ruby and enables you to use Qt Quick-based GUI from Ruby."
+  spec.homepage      = "https://github.com/seanchas116/ruby-qml"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+  spec.extensions = ["ext/qml/extconf.rb"]
+
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake", "~> 10.3"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'celluloid'
+  spec.add_development_dependency 'twitter'
+end

data/spec/assets/testobj.qml

@@ -0,0 +1,5 @@
+import QtQuick 2.0
+
+QtObject {
+  property string name: 'foo'
+}

data/spec/qml/access_spec.rb

@@ -0,0 +1,162 @@
+require 'spec_helper'
+
+describe QML::Access do
+  class Foo
+    include QML::Access
+
+    property :text
+    signal :some_signal, [:arg]
+
+    def some_method(a, b)
+      a + b
+    end
+
+    def variadic_method(*args)
+    end
+  end
+
+  class Bar < Foo
+    def some_method(a, b)
+      'overridden'
+    end
+
+    def bar_method
+      'bar'
+    end
+  end
+
+  let(:context) { QML::Context.new }
+  let(:component) { QML::Component.new context: context, data: data }
+  let(:root) { component.create }
+
+  describe '.register_to_qml' do
+
+    context 'when namespace, version, name are given' do
+
+      class Hoge
+        include QML::Access
+
+        register_to_qml under: 'HogeNS', version: '1.2', name: 'Hoge'
+
+        property :text
+
+        def some_method(a, b)
+          a + b
+        end
+      end
+
+      let(:data) do
+        <<-EOS
+          import QtQuick 2.2
+          import HogeNS 1.2
+          Item {
+            id: root
+            property var bound: hoge.text + hoge.text
+            Hoge { id: hoge }
+          }
+        EOS
+      end
+      it 'registers the class as a QML type' do
+        expect { component.create }.not_to raise_error
+      end
+      describe 'Hoge#some_method' do
+        it 'returns value' do
+          expect(root.qml_eval('hoge.some_method(100, 200)')).to eq 300
+        end
+      end
+      describe 'Hoge text property' do
+        it 'can be used to property binding' do
+          root.qml_eval('hoge').text = "foo"
+          expect(root.qml_eval('root').bound).to eq 'foofoo'
+          root.qml_eval('hoge').text = "bar"
+          expect(root.qml_eval('root').bound).to eq 'barbar'
+        end
+      end
+    end
+
+    context 'when arguments are omitted' do
+
+      module HogeModule
+        VERSION = '0.1.0'
+        class Hoge
+          include QML::Access
+          register_to_qml
+        end
+      end
+
+      let(:data) do
+        <<-EOS
+          import HogeModule 0.1
+          Hoge {}
+        EOS
+      end
+
+      it 'guesses them from the Ruby class name, namespace and VERSION constant' do
+        expect { component.create }.not_to raise_error
+      end
+    end
+  end
+
+  context 'when used in context' do
+
+    let(:data) do
+      <<-EOS
+        import QtQuick 2.2
+        Item {
+          id: root
+          property string text: foo.text + foo.text
+          Connections {
+            id: connections
+            target: foo
+            property var args
+            onSome_signal: {
+              args = [arg]
+            }
+          }
+        }
+      EOS
+    end
+    let(:foo) { Foo.new }
+    let(:bar) { Bar.new }
+
+    before do
+      context[:foo] = foo
+      context[:bar] = bar
+      root
+    end
+
+    describe 'Foo#some_method' do
+      it 'returns value' do
+        expect(root.qml_eval('foo.some_method(100, 200)')).to eq 300
+      end
+    end
+    describe 'Bar#some_method' do
+      it 'returns value' do
+        expect(root.qml_eval('bar.some_method(100, 200)')).to eq 'overridden'
+      end
+    end
+    describe 'Foo#variadic_method' do
+      it 'will not be exported' do
+        expect { root.qml_eval('foo.variadic_method()') }.to raise_error(QML::QMLError)
+      end
+    end
+    describe 'Foo text property' do
+      it 'can get and set value' do
+        root.qml_eval('foo').text = 'test'
+        expect(root.qml_eval('foo').text).to eq 'test'
+      end
+      it 'can be used for property binding' do
+        foo.text = 'hoge'
+        expect(root.qml_eval('root.text')).to eq 'hogehoge'
+        foo.text = 'piyo'
+        expect(root.qml_eval('root.text')).to eq 'piyopiyo'
+      end
+    end
+    describe 'Foo some_signal signal' do
+      it 'can be connected' do
+        foo.some_signal.emit('foo')
+        expect(root.qml_eval('connections.args')).to eq ['foo']
+      end
+    end
+  end
+end