fusuma 2.0.0 → 2.0.5

data/spec/lib/plugin/detectors/detector_spec.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+require './lib/fusuma/plugin/events/event'
+require './lib/fusuma/plugin/detectors/detector'
+require './lib/fusuma/config'
+require_relative '../buffers/dummy_buffer'
+require_relative './dummy_detector'
+
+module Fusuma
+  module Plugin
+    module Detectors
+      RSpec.describe DummyDetector do
+        before do
+          @detector = DummyDetector.new
+          @buffer = Buffers::DummyBuffer.new
+        end
+
+        around do |example|
+          ConfigHelper.load_config_yml = <<~CONFIG
+            plugin:
+             detectors:
+               dummy_detector:
+                 dummy: dummy
+          CONFIG
+
+          example.run
+
+          ConfigHelper.clear_config_yml
+        end
+
+        describe '#detect' do
+          it { expect(@detector.detect([@buffer])).to be_a(Events::Event) }
+        end
+
+        describe '#config_params' do
+          it { expect(@detector.config_params).to eq(dummy: 'dummy') }
+        end
+      end
+    end
+  end
+end

data/spec/lib/plugin/detectors/dummy_detector.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require './lib/fusuma/plugin/detectors/detector'
+require './lib/fusuma/plugin/buffers/buffer'
+require './lib/fusuma/plugin/events/records/index_record'
+
+module Fusuma
+  module Plugin
+    module Detectors
+      class DummyDetector < Detector
+        # @param buffers [Array<Buffers::Buffer>]
+        # @return [Event]
+        def detect(buffers)
+          buffers.each do |buffer|
+            next unless buffer.type == 'dummy'
+
+            record = Events::Records::IndexRecord.new(index: Config::Index.new(%w[dummy index]))
+            return create_event(record: record)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/plugin/detectors/pinch_detector_spec.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+require './lib/fusuma/plugin/detectors/pinch_detector'
+require './lib/fusuma/plugin/buffers/gesture_buffer'
+require './lib/fusuma/plugin/events/event'
+require './lib/fusuma/config'
+
+module Fusuma
+  module Plugin
+    module Detectors
+      RSpec.describe PinchDetector do
+        before do
+          @detector = PinchDetector.new
+          @buffer = Buffers::GestureBuffer.new
+        end
+
+        around do |example|
+          ConfigHelper.load_config_yml = <<~CONFIG
+            threshold:
+              rotate: 1
+          CONFIG
+
+          example.run
+
+          Config.custom_path = nil
+        end
+
+        describe '#detect' do
+          context 'with no pinch event in buffer' do
+            before do
+              @buffer.clear
+            end
+            it { expect(@detector.detect([@buffer])).to eq nil }
+          end
+
+          context 'with not enough pinch events in buffer' do
+            before do
+              deltas = [
+                Events::Records::GestureRecord::Delta.new(0, 0, 0, 0, 1, 0),
+                Events::Records::GestureRecord::Delta.new(0, 0, 0, 0, 1.1, 0)
+              ]
+              events = create_events(deltas: deltas)
+
+              events.each { |event| @buffer.buffer(event) }
+            end
+            it 'should have repeat record' do
+              expect(@detector.detect([@buffer]).record.trigger).to eq :repeat
+            end
+          end
+
+          context 'with enough pinch IN event' do
+            before do
+              deltas = [
+                Events::Records::GestureRecord::Delta.new(0, 0, 0, 0, 1.0, 0),
+                Events::Records::GestureRecord::Delta.new(0, 0, 0, 0, 1.0, 0),
+                Events::Records::GestureRecord::Delta.new(0, 0, 0, 0, 2.0, 0)
+              ]
+              events = create_events(deltas: deltas)
+
+              events.each { |event| @buffer.buffer(event) }
+            end
+            it { expect(@detector.detect([@buffer])).to all be_a Events::Event }
+            it { expect(@detector.detect([@buffer]).map(&:record)).to all be_a Events::Records::IndexRecord }
+            it { expect(@detector.detect([@buffer]).map(&:record).map(&:index)).to all be_a Config::Index }
+
+            it 'should detect 3 fingers pinch-in (oneshot/repeat)' do
+              events = @detector.detect([@buffer])
+              expect(events[0].record.index.keys.map(&:symbol))
+                .to eq([:pinch, 3, :in])
+              expect(events[1].record.index.keys.map(&:symbol))
+                .to eq([:pinch, 3, :in, :update])
+            end
+          end
+
+          context 'with enough pinch OUT event' do
+            before do
+              deltas = [
+                Events::Records::GestureRecord::Delta.new(0, 0, 0, 0, 1.0, 0),
+                Events::Records::GestureRecord::Delta.new(0, 0, 0, 0, 0.6, 0),
+                Events::Records::GestureRecord::Delta.new(0, 0, 0, 0, 0.3, 0)
+              ]
+              events = create_events(deltas: deltas)
+
+              events.each { |event| @buffer.buffer(event) }
+            end
+            it 'should detect 3 fingers pinch-out (oneshot/repeat)' do
+              events = @detector.detect([@buffer])
+              expect(events[0].record.index.keys.map(&:symbol))
+                .to eq([:pinch, 3, :out])
+              expect(events[1].record.index.keys.map(&:symbol))
+                .to eq([:pinch, 3, :out, :update])
+            end
+          end
+        end
+
+        private
+
+        def create_events(deltas: [])
+          record_type = PinchDetector::GESTURE_RECORD_TYPE
+          deltas.map do |delta|
+            status = if deltas[0].equal? delta
+                       'begin'
+                     else
+                       'update'
+                     end
+
+            gesture_record = Events::Records::GestureRecord.new(status: status,
+                                                                gesture: record_type,
+                                                                finger: 3,
+                                                                delta: delta)
+            Events::Event.new(tag: 'libinput_gesture_parser', record: gesture_record)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/plugin/detectors/rotate_detector_spec.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+require './lib/fusuma/plugin/detectors/rotate_detector'
+require './lib/fusuma/plugin/buffers/gesture_buffer'
+require './lib/fusuma/plugin/events/event'
+require './lib/fusuma/config'
+
+module Fusuma
+  module Plugin
+    module Detectors
+      RSpec.describe RotateDetector do
+        before do
+          @detector = RotateDetector.new
+          @buffer = Buffers::GestureBuffer.new
+        end
+
+        around do |example|
+          ConfigHelper.load_config_yml = <<~CONFIG
+            threshold:
+              rotate: 1
+          CONFIG
+
+          example.run
+
+          Config.custom_path = nil
+        end
+
+        describe '#detect' do
+          context 'with no rotate event in buffer' do
+            before do
+              @buffer.clear
+            end
+            it { expect(@detector.detect([@buffer])).to eq nil }
+          end
+
+          context 'with not enough rotate events in buffer' do
+            before do
+              deltas = [
+                Events::Records::GestureRecord::Delta.new(0, 0, 0, 0, 0, 0.4),
+                Events::Records::GestureRecord::Delta.new(0, 0, 0, 0, 0, 0.5)
+              ]
+              events = create_events(deltas: deltas)
+
+              events.each { |event| @buffer.buffer(event) }
+            end
+            it 'should have repeat record' do
+              expect(@detector.detect([@buffer]).record.trigger).to eq :repeat
+            end
+          end
+
+          context 'with enough rotate IN event' do
+            before do
+              deltas = [
+                Events::Records::GestureRecord::Delta.new(0, 0, 0, 0, 0, 0.5),
+                Events::Records::GestureRecord::Delta.new(0, 0, 0, 0, 0, 0.6),
+                Events::Records::GestureRecord::Delta.new(0, 0, 0, 0, 0, 0.6)
+              ]
+              events = create_events(deltas: deltas)
+
+              events.each { |event| @buffer.buffer(event) }
+            end
+            it { expect(@detector.detect([@buffer])).to all be_a Events::Event }
+            it {
+              expect(@detector.detect([@buffer]).map(&:record)).to all be_a Events::Records::IndexRecord
+            }
+            it {
+              expect(@detector.detect([@buffer]).map(&:record).map(&:index)).to all be_a Config::Index
+            }
+            it 'should detect 3 fingers rotate-clockwise (oneshot/repeat)' do
+              events = @detector.detect([@buffer])
+              expect(events[0].record.index.keys.map(&:symbol))
+                .to eq([:rotate, 3, :clockwise])
+              expect(events[1].record.index.keys.map(&:symbol))
+                .to eq([:rotate, 3, :clockwise, :update])
+            end
+          end
+
+          context 'with enough rotate OUT event' do
+            before do
+              deltas = [
+                Events::Records::GestureRecord::Delta.new(0, 0, 0, 0, 0, -0.5),
+                Events::Records::GestureRecord::Delta.new(0, 0, 0, 0, 0, -0.6),
+                Events::Records::GestureRecord::Delta.new(0, 0, 0, 0, 0, -0.6)
+              ]
+              events = create_events(deltas: deltas)
+
+              events.each { |event| @buffer.buffer(event) }
+            end
+            it 'should detect 3 fingers rotate-counterclockwise' do
+              events = @detector.detect([@buffer])
+              indexes = events.map { |e| e.record.index.keys.map(&:symbol) }
+              expect(indexes).to eq(
+                [
+                  [:rotate, 3, :counterclockwise],
+                  [:rotate, 3, :counterclockwise, :update]
+                ]
+              )
+            end
+          end
+        end
+
+        private
+
+        def create_events(deltas: [])
+          record_type = RotateDetector::GESTURE_RECORD_TYPE
+          deltas.map do |delta|
+            status = if deltas[0].equal? delta
+                       'begin'
+                     else
+                       'update'
+                     end
+
+            gesture_record = Events::Records::GestureRecord.new(status: status,
+                                                                gesture: record_type,
+                                                                finger: 3,
+                                                                delta: delta)
+            Events::Event.new(tag: 'libinput_gesture_parser', record: gesture_record)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/plugin/detectors/swipe_detector_spec.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+require './lib/fusuma/plugin/detectors/swipe_detector'
+require './lib/fusuma/plugin/buffers/gesture_buffer'
+require './lib/fusuma/plugin/events/records/gesture_record'
+require './lib/fusuma/config'
+
+module Fusuma
+  module Plugin
+    module Detectors
+      RSpec.describe SwipeDetector do
+        before do
+          @detector = SwipeDetector.new
+          @buffer = Buffers::GestureBuffer.new
+        end
+
+        around do |example|
+          ConfigHelper.load_config_yml = <<~CONFIG
+            threshold:
+              swipe: 1
+          CONFIG
+
+          example.run
+
+          Config.custom_path = nil
+        end
+
+        describe '#detect' do
+          context 'with no swipe event in buffer' do
+            before do
+              @buffer.clear
+            end
+            it { expect(@detector.detect([@buffer])).to eq nil }
+          end
+
+          context 'with not enough swipe events in buffer' do
+            before do
+              deltas = [
+                Events::Records::GestureRecord::Delta.new(0,  0, 0, 0, 0, 0), # begin
+                Events::Records::GestureRecord::Delta.new(20, 0, 0, 0, 0, 0)  # update
+              ]
+              events = create_events(deltas: deltas)
+
+              events.each { |event| @buffer.buffer(event) }
+            end
+            it 'should have repeat record' do
+              event = @detector.detect([@buffer])
+              expect(event.record.trigger).to eq :repeat
+            end
+          end
+
+          context 'with enough swipe RIGHT event' do
+            before do
+              deltas = [
+                Events::Records::GestureRecord::Delta.new(0,  0, 0, 0, 0, 0), # begin
+                Events::Records::GestureRecord::Delta.new(0,  0, 0, 0, 0, 0), # update
+                Events::Records::GestureRecord::Delta.new(31, 0, 0, 0, 0, 0)  # update
+              ]
+              events = create_events(deltas: deltas)
+
+              events.each { |event| @buffer.buffer(event) }
+            end
+            it { expect(@detector.detect([@buffer])).to all be_a Events::Event }
+            it { expect(@detector.detect([@buffer]).map(&:record)).to all be_a Events::Records::IndexRecord }
+            it { expect(@detector.detect([@buffer]).map(&:record).map(&:index)).to all be_a Config::Index }
+            it 'should detect 3 fingers swipe-right' do
+              events = @detector.detect([@buffer])
+              expect(events[0].record.index.keys.map(&:symbol))
+                .to eq([:swipe, 3, :right])
+              expect(events[1].record.index.keys.map(&:symbol))
+                .to eq([:swipe, 3, :right, :update])
+            end
+          end
+
+          context 'with enough swipe DOWN event' do
+            before do
+              deltas = [
+                Events::Records::GestureRecord::Delta.new(0, 0, 0, 0),
+                Events::Records::GestureRecord::Delta.new(0, 0, 0, 0),
+                Events::Records::GestureRecord::Delta.new(0, 31, 0, 0)
+              ]
+              events = create_events(deltas: deltas)
+
+              events.each { |event| @buffer.buffer(event) }
+            end
+            it 'should detect 3 fingers swipe-down' do
+              events = @detector.detect([@buffer])
+              expect(events[0].record.index.keys.map(&:symbol))
+                .to eq([:swipe, 3, :down])
+              expect(events[1].record.index.keys.map(&:symbol))
+                .to eq([:swipe, 3, :down, :update])
+            end
+          end
+        end
+
+        private
+
+        def create_events(deltas: [])
+          record_type = SwipeDetector::GESTURE_RECORD_TYPE
+          deltas.map do |delta|
+            status = if deltas[0].equal? delta
+                       'begin'
+                     else
+                       'update'
+                     end
+            gesture_record = Events::Records::GestureRecord.new(status: status,
+                                                                gesture: record_type,
+                                                                finger: 3,
+                                                                delta: delta)
+            Events::Event.new(tag: 'libinput_gesture_parser', record: gesture_record)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/plugin/events/event_spec.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require './lib/fusuma/plugin/events/event'
+
+module Fusuma
+  module Plugin
+    module Events
+      RSpec.describe Event do
+        let(:event) { Event.new(**args) }
+        let(:args) { { tag: 'text', record: 'dummy_text' } }
+
+        class DummyRecord < Records::Record
+        end
+
+        describe '#record' do
+          context 'with text' do
+            it { expect(event.record).to be_a Records::Record }
+          end
+
+          context 'with Record' do
+            let(:args) { { tag: 'dummy_record', record: DummyRecord.new } }
+
+            it { expect(event.record).to be_a Records::Record }
+          end
+        end
+      end
+    end
+  end
+end