qml 0.0.1

data/spec/qml/geometry/point_spec.rb

@@ -0,0 +1,4 @@
+require 'spec_helper'
+
+describe QML::Geometry::Point do
+end

data/spec/qml/geometry/rectangle_spec.rb

@@ -0,0 +1,4 @@
+require 'spec_helper'
+
+describe QML::Geometry::Rectangle do
+end

data/spec/qml/geometry/size_spec.rb

@@ -0,0 +1,4 @@
+require 'spec_helper'
+
+describe QML::Geometry::Size do
+end

data/spec/qml/plugin_loader_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe QML::PluginLoader do
+
+  let(:loader) { QML::PluginLoader.new path, 'rubyqml-testutil' }
+
+  describe 'load' do
+
+    context 'with signle path' do
+      let(:path) { QML::ROOT_PATH + 'ext/qml/plugins/testutil' + QML::PluginLoader.lib_filename('rubyqml-testutil') }
+      let(:loader) { QML::PluginLoader.new path }
+      it 'creates an object instance' do
+        loader.load
+        expect(loader.instance).to be_a QML::QtObjectBase
+      end
+    end
+
+    context 'with correct file path' do
+      let(:path) { QML::ROOT_PATH + 'ext/qml/plugins/testutil' }
+      it 'creates an object instance' do
+        loader.load
+        expect(loader.instance).to be_a QML::QtObjectBase
+      end
+    end
+
+    context 'with wrong file path' do
+      let(:path) { QML::ROOT_PATH + 'ext/qml/plugins/wrong' }
+      it 'fails with QML::PluginError' do
+        expect { loader.load }.to raise_error(QML::PluginError)
+      end
+    end
+  end
+end

data/spec/qml/qt_object_base_spec.rb

@@ -0,0 +1,119 @@
+require 'spec_helper'
+
+describe QML::QtObjectBase do
+
+  describe '#qml_eval' do
+
+    let(:component) do
+      QML::Component.new data: <<-EOS
+        import QtQuick 2.0
+        QtObject {
+          property string foo: 'foo'
+          property string bar: 'bar'
+        }
+      EOS
+    end
+    let(:object) { component.create }
+    let(:expression) { 'foo + bar' }
+    let(:result) { object.qml_eval(expression) }
+
+    it 'evaluates a JS expression in its QML scope' do
+      expect(result).to eq 'foobar'
+    end
+
+    context 'when expression is wrong' do
+      let(:expression) { 'hoge + piyo' }
+      it 'raises QML::QMLError' do
+        expect { result }.to raise_error(QML::QMLError)
+      end
+    end
+
+    context 'when object does not belong to context' do
+      let(:object) { QML::Plugins.test_util.createTestObject }
+      it 'raises QML::QMLError' do
+        expect { result }.to raise_error(QML::QMLError)
+      end
+    end
+  end
+
+  describe 'ownership' do
+    let(:ownership_test) { QML::Plugins.test_util.create_ownership_test }
+
+    context 'when it is returned from a method' do
+      it 'gets ownership of the object' do
+        checker = -> { QML::TestUtil::ObjectLifeChecker.new(ownership_test.create_object) }.call
+        QML.application.collect_garbage
+        expect(checker.alive?).to eq false
+      end
+    end
+
+    context 'when it is obtained from a property' do
+      it 'does not get ownership of the object' do
+        checker = -> { QML::TestUtil::ObjectLifeChecker.new(ownership_test.property_object) }.call
+        QML.application.collect_garbage
+        expect(checker.alive?).to eq true
+      end
+    end
+
+    context 'when it has a parent' do
+      it 'does not get ownership of the object' do
+        checker = -> { QML::TestUtil::ObjectLifeChecker.new(ownership_test.sub_object) }.call
+        QML.application.collect_garbage
+        expect(checker.alive?).to eq true
+      end
+    end
+
+    context 'when it is created by component' do
+      let(:component) do
+        QML::Component.new data: <<-EOS
+          import QtQuick 2.0
+          Item {}
+        EOS
+      end
+      it 'gets ownership' do
+        checker = -> { QML::TestUtil::ObjectLifeChecker.new(component.create) }.call
+        QML.application.collect_garbage
+        expect(checker.alive?).to eq false
+      end
+    end
+
+    describe '#managed?' do
+      [true, false].each do |cond|
+        context "when managed = #{cond}" do
+          it "returns #{cond}" do
+            obj = ownership_test.create_object
+            obj.managed = cond
+            expect(obj.managed?).to eq cond
+          end
+        end
+      end
+    end
+
+    context 'on garbage collection' do
+
+      context 'when managed' do
+        it 'gets destroyed' do
+          checker = -> {
+            obj = ownership_test.create_object
+            obj.managed = true
+            QML::TestUtil::ObjectLifeChecker.new(obj)
+          }.call
+          QML.application.collect_garbage
+          expect(checker.alive?).to eq false
+        end
+      end
+
+      context 'when not managed' do
+        it 'does not get destroyed' do
+          checker = -> {
+            obj = ownership_test.create_object
+            obj.managed = false
+            QML::TestUtil::ObjectLifeChecker.new(obj)
+          }.call
+          QML.application.collect_garbage
+          expect(checker.alive?).to eq true
+        end
+      end
+    end
+  end
+end

data/spec/qml/reactive/object_spec.rb

@@ -0,0 +1,273 @@
+require 'spec_helper'
+
+describe QML::Reactive::Object do
+
+  class Button
+    include QML::Reactive::Object
+    signal :pressed, [:pos]
+    variadic_signal :message
+    property :name, 'button'
+    property :id, 0
+    property :name_double do
+      name + name
+    end
+    on :pressed do |pos|
+      self.name = pos
+    end
+    on_changed :id do
+      self.name = "ID: #{id}"
+    end
+    on_changed :id do
+    end
+    alias_property :title, :name
+    alias_signal :clicked, :pressed
+  end
+
+  class ToggleButton < Button
+    signal :pressed, [:x, :y]
+    signal :toggled, [:on]
+    property(:name) { 'toggle button' }
+    property(:info) { 'some info' }
+  end
+
+  let(:button) { Button.new }
+  let(:toggle_button) { ToggleButton.new }
+
+  describe '.property' do
+
+    it 'defines getter' do
+      expect(button.name).to eq('button')
+    end
+
+    it 'defines setter' do
+      button.name = 'hoge'
+      expect(button.name).to eq('hoge')
+    end
+
+    it 'can set property binding' do
+      button.name = 'poyo'
+      expect(button.name_double).to eq 'poyopoyo'
+    end
+
+    it 'defines notify signal' do
+      spy = QML::Reactive::SignalSpy.new(button.name_changed)
+      button.name = 'hoge'
+      expect(spy.args.last).to eq(['hoge'])
+    end
+
+    it 'returns the name' do
+      result = nil
+      Class.new do
+        include QML::Reactive::Object
+        result = property :foo
+      end
+      expect(result).to eq :foo
+    end
+
+    context 'in subclass' do
+
+      it 'defines property in subclass' do
+        expect(toggle_button.info).to eq('some info')
+      end
+
+      it 'does not define property in superclass' do
+        expect(button.properties).not_to include(:info)
+      end
+
+      it 'overrides superclass property' do
+        expect(toggle_button.name).to eq('toggle button')
+      end
+    end
+  end
+
+  describe '.alias_property' do
+    it 'returns the name' do
+      result = nil
+      Class.new do
+        include QML::Reactive::Object
+        property :foo
+        result = alias_property :bar, :foo
+      end
+      expect(result).to eq :bar
+    end
+    it 'aliases a property' do
+      expect(button.property(:title)).to eq button.property(:name)
+      expect(button.signal(:title_changed)).to eq button.signal(:name_changed)
+    end
+  end
+
+  describe '.signal' do
+
+    it 'defines a signal' do
+      spy = button.pressed.spy
+      button.pressed.emit([10, 22])
+      expect(spy.args.last).to eq([[10, 22]])
+    end
+
+    it 'returns the name' do
+      result = nil
+      Class.new do
+        include QML::Reactive::Object
+        result = signal :sig, []
+      end
+      expect(result).to eq(:sig)
+    end
+
+    context 'when the args parameter is not passed' do
+      it 'defines a variadic signal' do
+        spy = button.message.spy
+        button.message.emit(*%w{emitting some message})
+        expect(spy.args.last).to eq(%w{emitting some message})
+      end
+    end
+
+    context 'in subclass' do
+
+      it 'defines signal in subclass' do
+        spy = toggle_button.toggled.spy
+        toggle_button.toggled.emit(true)
+        expect(spy.args.last).to eq([true])
+      end
+
+      it 'does not define signal in superclass' do
+        expect(button.signals).not_to include(:toggled)
+      end
+
+      it 'overrides superclass signal' do
+        signal = toggle_button.pressed
+        expect(signal.arity).to eq(2)
+      end
+
+      it 'defines overridden signal in subclass' do
+        spy = toggle_button.pressed.spy
+        toggle_button.pressed.emit(10, 20)
+        expect(spy.args.last).to eq([10, 20])
+      end
+    end
+  end
+
+  describe '.alias_signal' do
+
+    it 'returns the name' do
+      result = nil
+      Class.new do
+        include QML::Reactive::Object
+        signal :foo, []
+        result = alias_signal :bar, :foo
+      end
+      expect(result).to eq :bar
+    end
+
+    it 'aliases a signal' do
+      expect(button.clicked).to eq button.pressed
+    end
+  end
+
+  describe '.on' do
+    it 'adds signal handler' do
+      button.pressed.emit "pressed at top"
+      expect(button.name).to eq "pressed at top"
+    end
+  end
+
+  describe '.on_changed' do
+    it 'add property changed signal handler' do
+      button.id = 2
+      expect(button.name).to eq "ID: 2"
+    end
+  end
+
+  describe '.instance_signals' do
+    context 'when include_super is false' do
+      it 'returns all signal definitions of the class' do
+        signals = ToggleButton.instance_signals(false)
+        expect(signals).to match_array %i{pressed toggled name_changed info_changed}
+      end
+    end
+
+    context 'when include_super is not specified' do
+      it 'returns all signal definitions of the class and its superclasses' do
+        signals = ToggleButton.instance_signals
+        expect(signals).to match_array %i{pressed message toggled name_changed id_changed info_changed name_double_changed clicked title_changed}
+      end
+    end
+  end
+
+  describe '.instance_properties' do
+    context 'when include_super is false' do
+      it 'returns all property definitions of the class' do
+        properties = ToggleButton.instance_properties(false)
+        expect(properties).to match_array %i{name info}
+      end
+    end
+
+    context 'when include_super is not specified' do
+      it 'returns all property definitions of the class and its superclasses' do
+        properties = ToggleButton.instance_properties
+        expect(properties).to match_array %i{name id info name_double title}
+      end
+    end
+  end
+
+  describe '.instance_signal' do
+    it 'returns the UnboundSignal for name' do
+      s = ToggleButton.instance_signal(:pressed)
+      expect(s).to be_a QML::Reactive::UnboundSignal
+      expect(s.name).to eq :pressed
+      expect(s.arity).to eq 2
+    end
+    context 'when signal does not exist' do
+      it 'fails with NameError' do
+        expect { ToggleButton.instance_signal(:non_existent) }.to raise_error(NameError)
+      end
+    end
+  end
+
+  describe '.instance_property' do
+    it 'returns the UnboundProperty for name' do
+      p = ToggleButton.instance_property(:name)
+      expect(p).to be_a QML::Reactive::UnboundProperty
+      expect(p.name).to eq :name
+      expect(p.initial_binding.call).to eq 'toggle button'
+    end
+    context 'when property does not exist' do
+      it 'fails with NameError' do
+        expect { ToggleButton.instance_property(:non_existent) }.to raise_error(NameError)
+      end
+    end
+  end
+
+  describe '#signals' do
+    it 'returns signal names for object' do
+      expect(toggle_button.signals).to match_array %i{pressed message toggled id_changed name_changed info_changed name_double_changed clicked title_changed}
+    end
+  end
+
+  describe '#properties' do
+    it 'return property names for object' do
+      expect(toggle_button.properties).to match_array %i{name id info name_double title}
+    end
+  end
+
+  describe '#signal' do
+    it 'returns Signal for name' do
+      expect(toggle_button.signal(:pressed)).to eq toggle_button.pressed
+    end
+    context 'when signal does not exist' do
+      it 'fails with NameError' do
+        expect { toggle_button.signal(:non_existent) }.to raise_error(NameError)
+      end
+    end
+  end
+
+  describe '#property' do
+    it 'returns Property for name' do
+      expect(toggle_button.property(:name).value).to eq toggle_button.name
+    end
+    context 'when property does not exist' do
+      it 'fails with NameError' do
+        expect { toggle_button.property(:non_existent) }.to raise_error(NameError)
+      end
+    end
+  end
+end

data/spec/qml/reactive/property_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+describe QML::Reactive::Property do
+
+  describe '#initialize' do
+
+    context 'when a value is given' do
+      it 'initializes with the value' do
+        p = QML::Reactive::Property.new(2)
+        expect(p.value).to eq(2)
+      end
+    end
+
+    context 'when a block is given' do
+      it 'initializes with the property binding' do
+        p1 = QML::Reactive::Property.new(2)
+        p2 = QML::Reactive::Property.new { p1.value + 2 }
+        p1.value = 10
+        expect(p2.value).to eq(12)
+      end
+    end
+  end
+
+  describe 'access to the value' do
+    describe '#value, #value=' do
+      it 'sets and gets the contained value' do
+        property = QML::Reactive::Property.new
+        property.value = '(´･_･`)'
+        expect(property.value).to eq('(´･_･`)')
+      end
+    end
+  end
+
+  describe 'property binding' do
+
+    describe '#bind' do
+
+      it 'sets a property binding' do
+        p1 = QML::Reactive::Property.new 'foo'
+        p2 = QML::Reactive::Property.new 'bar'
+        p3 = QML::Reactive::Property.new
+        p4 = QML::Reactive::Property.new
+        p3.bind { p1.value + p2.value }
+        p4.bind { p3.value }
+        p1.value = 'hoge'
+        p2.value = 'piyo'
+        expect(p3.value).to eq('hogepiyo')
+        expect(p4.value).to eq('hogepiyo')
+      end
+
+      context 'when binding is recursive' do
+        it 'raises error' do
+          property = QML::Reactive::Property.new
+          expect{ property.bind { property.value } }.to raise_error(QML::Reactive::Error)
+        end
+      end
+    end
+  end
+
+  describe '#changed' do
+    it 'returns a signal that is emitted when the value is changed' do
+      property = QML::Reactive::Property.new
+      changed_value = nil
+      property.changed.connect { |val| changed_value = val }
+
+      property.value = 'piyopiyo'
+      expect(changed_value).to eq('piyopiyo')
+    end
+  end
+end