qml 0.0.7 → 1.0.0

data/spec/qml/dispatchable_spec.rb

@@ -1,26 +0,0 @@
-require 'spec_helper'
-
-describe QML::Dispatchable do
-  class DispatchableFoo
-    include QML::Dispatchable
-    attr_accessor :value
-  end
-
-  describe '#later' do
-    it 'queues a method call as a task to the dispatcher' do
-      foo = DispatchableFoo.new
-      foo.later.value = 'hoge'
-      QML.application.process_events # wait for event loop hook to be enabled
-      QML.application.process_events
-      expect(foo.value).to eq 'hoge'
-    end
-  end
-end
-
-[QML::Access, QML::QtObjectBase, QML::Data::ListModel].each do |mod|
-  describe mod do
-    it 'includes Dispatchable' do
-      expect(mod.include?(QML::Dispatchable)).to eq true
-    end
-  end
-end

data/spec/qml/dispatcher_spec.rb

@@ -1,71 +0,0 @@
-require 'spec_helper'
-
-describe QML::Dispatcher do
-
-  let(:dispatcher) { QML::Dispatcher.instance }
-
-  describe '#empty?' do
-    context 'when it has no task' do
-      it 'returns true' do
-        dispatcher.run_tasks until dispatcher.empty?
-        expect(dispatcher.empty?).to eq true
-      end
-    end
-    context 'when it has tasks' do
-      it 'returns false' do
-        dispatcher.add_task {}
-        expect(dispatcher.empty?).to eq false
-      end
-    end
-  end
-
-  describe '#add_task' do
-    before do
-      dispatcher.add_task {}
-    end
-
-    it 'adds a task' do
-      expect(dispatcher.empty?).to eq false
-    end
-
-    it 'sets the event loop hook enabled later' do
-      QML.application.process_events
-      expect(QML::Kernel.event_loop_hook_timer.active).to eq true
-    end
-  end
-
-  describe '#run_tasks' do
-    let(:finished) { [] }
-    before do
-      2.times.each do |i|
-        dispatcher.add_task do
-          finished[i] = true
-        end
-      end
-      dispatcher.run_tasks until dispatcher.empty?
-    end
-
-    it 'runs queued tasks' do
-      expect(finished).to eq [true, true]
-    end
-
-    it 'sets the event loop hook disabled when finished later' do
-      QML.application.process_events
-      expect(QML::Kernel.event_loop_hook_timer.active).to eq false
-    end
-  end
-end
-
-describe QML do
-  describe '.later' do
-    it 'adds a task to the dispatcher and do it later in event loop' do
-      finished = false
-      QML.later do
-        finished = true
-      end
-      QML.application.process_events # wait for event loop hook to be enabled
-      QML.application.process_events
-      expect(finished).to eq true
-    end
-  end
-end

data/spec/qml/geometry/point_spec.rb

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

data/spec/qml/geometry/rectangle_spec.rb

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

data/spec/qml/geometry/size_spec.rb

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

data/spec/qml/image_provider_spec.rb

@@ -1,33 +0,0 @@
-require 'spec_helper'
-
-describe QML::ImageProvider do
-
-  describe '#request' do
-    it 'is not implemented by default' do
-      expect { QML::ImageProvider.new.request(nil) }.to raise_error(NotImplementedError)
-    end
-  end
-
-  context 'with test image' do
-    let(:klass) do
-      Class.new QML::ImageProvider do
-        attr_reader :image
-
-        def initialize
-          @image = (Pathname(__FILE__) + '../../assets/test.png').binread
-          super
-        end
-
-        def request(req)
-          req.finish(image)
-        end
-      end
-    end
-    let(:image_provider) { klass.new }
-
-    it 'provides image to QML' do
-      test = QML::Plugins.test_util.create_image_provider_test
-      expect(test.request_and_compare(image_provider.qt_image_provider, 'test', image_provider.image)).to eq true
-    end
-  end
-end

data/spec/qml/qt_object_base_spec.rb

@@ -1,119 +0,0 @@
-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

@@ -1,249 +0,0 @@
-require 'spec_helper'
-
-describe QML::Reactive::Object do
-
-  include_context 'Reactive test objects'
-
-  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
-    it 'calls all connections including superclass' do
-      toggle_button.id = 3
-      expect(toggle_button.name).to eq "ID: 3"
-      expect(toggle_button.info).to eq "ID changed"
-    end
-  end
-
-  describe '.instance_signals' do
-    context 'when include_super is false' do
-      it 'returns all signal definitions of the class' do
-        signals = toggle_button_class.instance_signals(false)
-        expect(signals).to match_array %w{pressed toggled name_changed info_changed}.map(&:to_sym)
-      end
-    end
-
-    context 'when include_super is not specified' do
-      it 'returns all signal definitions of the class and its superclasses' do
-        signals = toggle_button_class.instance_signals
-        expect(signals).to match_array %w{pressed message toggled name_changed id_changed info_changed name_double_changed clicked title_changed}.map(&:to_sym)
-      end
-    end
-  end
-
-  describe '.instance_properties' do
-    context 'when include_super is false' do
-      it 'returns all property definitions of the class' do
-        properties = toggle_button_class.instance_properties(false)
-        expect(properties).to match_array %w{name info}.map(&:to_sym)
-      end
-    end
-
-    context 'when include_super is not specified' do
-      it 'returns all property definitions of the class and its superclasses' do
-        properties = toggle_button_class.instance_properties
-        expect(properties).to match_array %w{name id info name_double title}.map(&:to_sym)
-      end
-    end
-  end
-
-  describe '.instance_signal' do
-    it 'returns the UnboundSignal for name' do
-      s = toggle_button_class.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 { toggle_button_class.instance_signal(:non_existent) }.to raise_error(NameError)
-      end
-    end
-  end
-
-  describe '.instance_property' do
-    it 'returns the UnboundProperty for name' do
-      p = toggle_button_class.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 { toggle_button_class.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 %w{pressed message toggled id_changed name_changed info_changed name_double_changed clicked title_changed}.map(&:to_sym)
-    end
-  end
-
-  describe '#properties' do
-    it 'return property names for object' do
-      expect(toggle_button.properties).to match_array %w{name id info name_double title}.map(&:to_sym)
-    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