qml 0.0.7 → 1.0.0

data/spec/qml/reactive/property_spec.rb

@@ -1,70 +0,0 @@
-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 = 'hogehoge'
-        expect(property.value).to eq('hogehoge')
-      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

data/spec/qml/reactive/signal_spec.rb

@@ -1,191 +0,0 @@
-require 'spec_helper'
-
-describe QML::Reactive::Signal do
-
-  before do
-    @signal = QML::Reactive::Signal.new([:foo, :bar])
-    @variadic_signal = QML::Reactive::Signal.new(nil)
-  end
-
-  describe 'connection' do
-
-    describe '#connect, #emit' do
-
-      context 'when non-variadic' do
-
-        before do
-          @signal.connect { |foo, bar| @received = [foo, bar] }
-        end
-
-        it 'connects a block and calls it' do
-          @signal.emit('apple', 'orange')
-          expect(@received).to eq(['apple', 'orange'])
-        end
-
-        context 'when the number of arguments is wrong' do
-          it 'fails with an ArgumentError' do
-            expect { @signal.emit('apple') }.to raise_error(ArgumentError)
-          end
-        end
-      end
-
-      context 'when variadic' do
-
-        it 'connects a block and calls it' do
-          received = nil
-          @variadic_signal.connect { |foo, bar| received = [foo, bar] }
-          @variadic_signal.emit('apple', 'orange')
-          expect(received).to eq(['apple', 'orange'])
-        end
-      end
-
-      it 'calls connected blocks in the order they have been conncted' do
-        received = []
-        @signal.connect { received << 'first' }
-        @signal.connect { received << 'second' }
-        @signal.emit('foo', 'bar')
-        expect(received).to eq(['first', 'second'])
-      end
-    end
-
-    describe '#each' do
-      it 'is an alias of #connect' do
-        expect(@signal.method(:each)).to eq @signal.method(:connect)
-      end
-    end
-
-    describe '::Connection#disconnect' do
-
-      it 'disconnects the connection' do
-        connection = @signal.connect { |foo, bar| @received = foo + bar }
-        @signal.emit('apple', 'orange')
-        connection.disconnect
-        @signal.emit('banana', 'grape')
-        expect(@received).to eq('appleorange')
-      end
-
-      it 'disconnects the whole chained connections if possible' do
-        signal = QML::Reactive::Signal.new [:arg]
-        mapped = signal.map { |arg| arg * 2 }
-
-        connection = mapped.connect {}
-
-        connection.disconnect
-        expect(signal.connection_count).to eq(0)
-      end
-    end
-
-    describe '#connection_count' do
-      it 'returns the number of connections' do
-        prc1 = ->(foo, bar) {}
-        prc2 = ->(foo, bar) {}
-        @signal.connect(&prc1)
-        @signal.connect(&prc2)
-        expect(@signal.connection_count).to eq(2)
-      end
-    end
-  end
-
-  describe 'attributes' do
-
-    describe '#arity' do
-
-      context 'when non-variadic' do
-        it 'returns the number of arguments' do
-          expect(@signal.arity).to eq(2)
-        end
-      end
-
-      context 'when variadic' do
-        it 'returns the number of arguments' do
-          expect(@variadic_signal.arity).to eq(-1)
-        end
-      end
-    end
-
-    describe '#parameters' do
-
-      context 'when non-variadic' do
-        it 'returns the parameter information' do
-          expect(@signal.parameters).to eq([[:req, :foo], [:req, :bar]])
-        end
-      end
-
-      context 'when variadic' do
-        it 'returns the parameter information' do
-          expect(@variadic_signal.parameters).to eq([[:rest, :args]])
-        end
-      end
-    end
-  end
-
-  describe 'alternatives for #emit' do
-
-    before do
-      @signal.connect { |foo, bar| @received = foo + bar }
-    end
-
-    describe '#to_proc' do
-      it 'returns a Proc that emits the original signal' do
-        prc = @signal.to_proc
-        prc.call('foo', 'bar')
-        expect(prc).to be_a(Proc)
-        expect(@received).to eq('foobar')
-      end
-    end
-
-    describe '#[]' do
-      it 'is an alias of #emit' do
-        @signal["some", "text"]
-        expect(@received).to eq("sometext")
-      end
-    end
-
-    describe '#call' do
-      it 'is an alias of #emit' do
-        @signal.call("some", "text")
-        expect(@received).to eq("sometext")
-      end
-    end
-  end
-
-  describe 'transformations' do
-
-    describe '#map' do
-      it 'returns another Signal that transforms the original signal parameters' do
-        received = nil
-        @signal
-          .map { |foo, bar| foo * bar }
-          .connect { |arg| received = arg }
-        @signal.emit(20, 30)
-        expect(received).to eq(600)
-      end
-    end
-
-    describe '#select' do
-      it 'returns another Signal which is filtered by the given block' do
-        count = 0
-        @signal.select { |foo| foo % 2 == 0 } .connect { count += 1 }
-        10.times { |i| @signal.emit(i, i) }
-        expect(count).to eq(5)
-      end
-    end
-
-    describe '#merge' do
-      it 'merges multiple signals' do
-        received = []
-
-        signal = QML::Reactive::Signal.new [:foo]
-        signal2 = QML::Reactive::Signal.new [:foo]
-        signal.merge(signal2).connect { |foo| received << foo }
-
-        signal.emit(:one)
-        signal2.emit(:two)
-        signal.emit(:three)
-        expect(received).to eq([:one, :two, :three])
-      end
-    end
-  end
-end
-
-

data/spec/qml/reactive/signal_spy_spec.rb

@@ -1,26 +0,0 @@
-require 'spec_helper'
-
-describe QML::Reactive::SignalSpy do
-
-  it 'records signal emittion' do
-    signal = QML::Reactive::Signal.new([:arg1, :arg2])
-    spy = QML::Reactive::SignalSpy.new(signal)
-    signal.emit(10, 20)
-    signal.emit('foo', 'bar')
-    expect(spy.args).to eq([[10, 20], ['foo', 'bar']])
-  end
-
-end
-
-describe QML::Reactive::Signal do
-
-  describe '#spy' do
-    it 'returns a SignalSpy for the signal' do
-      signal = QML::Reactive::Signal.new([:arg1, :arg2])
-      spy = signal.spy
-      signal.emit(10, 20)
-      signal.emit('foo', 'bar')
-      expect(spy.args).to eq([[10, 20], ['foo', 'bar']])
-    end
-  end
-end

data/spec/qml/reactive/unbound_property_spec.rb

@@ -1,40 +0,0 @@
-require 'spec_helper'
-
-describe QML::Reactive::UnboundProperty do
-  include_context 'Reactive test objects'
-  let(:property) { button_class.instance_property(:name) }
-  let(:alias_property) { button_class.instance_property(:title) }
-
-  describe '#name' do
-    it 'returns the name' do
-      expect(property.name).to eq(:name)
-      expect(alias_property.name).to eq(:title)
-    end
-  end
-
-  describe '#owner' do
-    it 'returns the owner class' do
-      expect(property.owner).to be(button_class)
-      expect(alias_property.owner).to be(button_class)
-    end
-  end
-
-  describe '#original' do
-    it 'returns the original name of the alias property' do
-      expect(alias_property.original).to eq(:name)
-    end
-  end
-
-  describe '#alias?' do
-    context 'for non-alias properties' do
-      it 'returns false' do
-        expect(property).not_to be_alias
-      end
-    end
-    context 'for alias properties' do
-      it 'returns true' do
-        expect(alias_property).to be_alias
-      end
-    end
-  end
-end

data/spec/qml/reactive/unbound_signal_spec.rb

@@ -1,70 +0,0 @@
-require 'spec_helper'
-
-describe QML::Reactive::UnboundSignal do
-  include_context 'Reactive test objects'
-  let(:signal) { button_class.instance_signal(:pressed) }
-  let(:alias_signal) { button_class.instance_signal(:clicked) }
-  let(:variadic_signal) { button_class.instance_signal(:message) }
-
-  describe '#name' do
-    it 'returns the name' do
-      expect(signal.name).to eq(:pressed)
-      expect(alias_signal.name).to eq(:clicked)
-    end
-  end
-
-  describe '#owner' do
-    it 'returns the owner class' do
-      expect(signal.owner).to be(button_class)
-      expect(alias_signal.owner).to be(button_class)
-    end
-  end
-
-  describe '#original' do
-    it 'returns the original name of the alias signal' do
-      expect(alias_signal.original).to eq(:pressed)
-    end
-  end
-
-  describe '#variadic?' do
-    context 'for non-variadic signals' do
-      it 'returns false' do
-        expect(signal).not_to be_variadic
-      end
-    end
-    context 'for variadic signals' do
-      it 'returns true' do
-        expect(variadic_signal).to be_variadic
-      end
-    end
-  end
-
-  describe '#alias?' do
-    context 'for non-alias signals' do
-      it 'returns false' do
-        expect(signal).not_to be_alias
-      end
-    end
-    context 'for alias signals' do
-      it 'returns true' do
-        expect(alias_signal).to be_alias
-      end
-    end
-  end
-
-  describe '#arity' do
-    it 'returns the number of arguments' do
-      expect(signal.arity).to eq(1)
-      expect(variadic_signal.arity).to eq(-1)
-      expect(alias_signal.arity).to eq(1)
-    end
-  end
-
-  describe '#parameters' do
-    it 'returns parameter names' do
-      expect(signal.parameters).to eq([[:req, :pos]])
-      expect(alias_signal.parameters).to eq([[:req, :pos]])
-      expect(variadic_signal.parameters).to eq([[:rest, :args]])
-    end
-  end
-end

data/spec/qml/test_object_spec.rb

@@ -1,186 +0,0 @@
-require 'spec_helper'
-
-describe "test object" do
-
-  let(:plugin) { QML::Plugins.test_util }
-  let(:obj) { plugin.createTestObject }
-
-  describe '#normalMethod' do
-
-    it 'should call the method' do
-      expect(obj.normalMethod(1, "23")).to eq(24)
-    end
-
-    context 'if the arguments are not convertible' do
-      it 'should raise error' do
-        expect { obj.normalMethod([1, 2], 'bar') }.to raise_error QML::MethodError
-      end
-    end
-
-    context 'if the number of arguments is wrong' do
-      it 'should raise error' do
-        expect { obj.normalMethod(1) }.to raise_error QML::MethodError
-      end
-    end
-  end
-
-  describe '#normal_method' do
-    it 'is same as #normalMethod' do
-      expect(obj.normalMethod(1, "23")).to eq(24)
-    end
-  end
-
-  describe '#variantMethod' do
-
-    it 'should call the method with QVariant arguments' do
-      expect(obj.variantMethod(20, [1, 3, 4, 9])).to eq(37)
-    end
-  end
-
-  describe '#overloadedMethod' do
-
-    it 'should call the method with the same arity' do
-      expect(obj.overloadedMethod('foo', 1)).to eq('2 params')
-    end
-
-    context 'when multiple methods with the same arity are provided' do
-
-      it 'should call the method defined last' do
-        expect(obj.overloadedMethod('hoge')).to eq('last')
-      end
-    end
-  end
-
-  describe '#someSignal signal' do
-
-    it 'should emit the signal' do
-      spy = QML::Reactive::SignalSpy.new(obj.someSignal)
-      obj.emitSomeSignal('poyopoyo')
-      expect(spy.args.first).to eq(['poyopoyo'])
-    end
-  end
-
-  describe '#some_signal signal' do
-
-    it 'is same as #someSignal' do
-      spy = QML::Reactive::SignalSpy.new(obj.some_signal)
-      obj.emit_some_signal('poyopoyo')
-      expect(spy.args.first).to eq(['poyopoyo'])
-    end
-  end
-
-  describe '#throwingMethod' do
-    it 'raises a QML::CxxError' do
-      expect { obj.throwingMethod }.to raise_error(QML::CppError, "<std::runtime_error> test error")
-    end
-  end
-
-  describe '#metaObjectMethod' do
-    it 'returns the QML::MetaObject of the test object' do
-      expect(obj.metaObjectMethod).to eq obj.class.meta_object
-    end
-  end
-
-  describe '#selfReturningMethod' do
-    it 'returns the same Ruby object' do
-      expect(obj.selfReturningMethod).to be obj
-    end
-  end
-
-  describe '#name property' do
-
-    it 'should be set' do
-      obj.name = 'abcd'
-      expect(obj.getName).to eq('abcd')
-    end
-
-    it 'should notify when changed' do
-      spy = QML::Reactive::SignalSpy.new(obj.name_changed)
-      obj.name = 'hogepoyo'
-      expect(spy.args.first).to eq(['hogepoyo'])
-    end
-
-    context 'with wrong type' do
-
-      it 'raise error' do
-        expect { obj.name = 123 }.to raise_error QML::PropertyError
-      end
-    end
-  end
-
-  describe '#someValue property' do
-    context 'as #some_value' do
-      it 'can be set and get' do
-        obj.some_value = 123
-        expect(obj.some_value).to eq 123
-      end
-    end
-  end
-
-  describe 'enums' do
-    
-    it 'should be set' do
-      k = obj.class
-      expect(k::Foo).to eq(0)
-      expect(k::Bar).to eq(1)
-      expect(k::FooBar).to eq(2)
-      expect(k::FOO_BAR).to eq(2)
-      expect(k::Enums).to match_array [0,1,2]
-    end
-
-    it 'can be set and get' do
-      obj.enum_value = obj.class::FOO_BAR
-      expect(obj.enum_value).to eq(obj.class::FOO_BAR)
-    end
-  end
-
-  describe 'QtObjectBase#inspect' do
-    it 'inspects the class name and property values' do
-      expect(obj.inspect).to eq %{#<[class for RubyQml::TestObject]:#{obj.__id__} enumValue=0 name="" objectName="" someValue=0.0>}
-    end
-  end
-
-  context 'in subclass' do
-    let(:subobj) { plugin.createTestObject }
-    it "can call TestObject's method" do
-      expect(subobj.normalMethod(1, "23")).to eq(24)
-    end
-  end
-
-  context 'in non-main threads' do
-
-    require 'celluloid'
-
-    class TestCaller
-      include Celluloid
-
-      def initialize(obj)
-        @obj = obj
-      end
-
-      def call(method, *args)
-        @obj.public_send(method, *args)
-      rescue => e
-        e
-      end
-    end
-
-    let(:test_caller) { TestCaller.new(obj) }
-
-    describe '#normal_method' do
-      it 'fails' do
-        expect(test_caller.call(:normal_method, 1, "23")).to be_a QML::InvalidThreadError
-      end
-    end
-    describe '#name' do
-      it 'fails' do
-        expect(test_caller.call(:name)).to be_a QML::InvalidThreadError
-      end
-    end
-    describe '#name=' do
-      it 'fails' do
-        expect(test_caller.call(:name=, "hoge")).to be_a QML::InvalidThreadError
-      end
-    end
-  end
-end