fusuma 2.0.0 → 2.0.1

data/spec/lib/plugin/base_spec.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require './lib/fusuma/plugin/base'
+require './lib/fusuma/plugin/manager'
+
+module Fusuma
+  module Plugin
+    class DummyPlugin < Base
+      def config_param_types
+        {
+          dummy_string: String,
+          dummy_list: Array,
+          dummy_bool: [TrueClass, FalseClass]
+        }
+      end
+    end
+
+    class DummyChildPlugin < DummyPlugin
+    end
+
+    RSpec.describe DummyPlugin do
+      before do
+        @dummy_plugin = DummyPlugin.new
+        @dummy_child_plugin = DummyChildPlugin.new
+
+        ConfigHelper.load_config_yml = <<-CONFIG
+        plugin:
+          dummy_plugin:
+            dummy_string: dummy
+            dummy_list:
+              - 1
+              - 2
+              - 3
+            dummy_bool: true
+        CONFIG
+      end
+
+      after do
+        Config.custom_path = nil
+      end
+      describe '.inherited' do
+        it 'should add required class to subclass on Manager' do
+          expect(Manager.plugins[Base.name]).to include(DummyPlugin)
+        end
+      end
+
+      describe '.plugins' do
+        it 'should list plugins' do
+          expect(DummyPlugin.plugins).to eq([DummyChildPlugin])
+        end
+      end
+
+      describe '#config_param_types' do
+        it 'should define class for config params' do
+          expect(@dummy_plugin.config_param_types).to be_a Hash
+        end
+      end
+
+      describe '#config_params' do
+        it 'should fetch options from config' do
+          expect(@dummy_plugin.config_params).to be_a Hash
+          expect(@dummy_plugin.config_params(:dummy_string)).to be_a String
+        end
+      end
+
+      describe '#config_index' do
+        it 'should return index' do
+          expect(@dummy_plugin.config_index).to be_a Config::Index
+        end
+      end
+    end
+  end
+end

data/spec/lib/plugin/buffers/buffer_spec.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+require './lib/fusuma/plugin/events/event'
+require_relative './dummy_buffer'
+
+module Fusuma
+  module Plugin
+    module Buffers
+      RSpec.describe DummyBuffer do
+        before do
+          @buffer = DummyBuffer.new
+        end
+
+        describe '#type' do
+          subject { @buffer.type }
+          it { is_expected.to eq 'dummy' }
+        end
+
+        describe '#buffer' do
+          it 'should buffer event' do
+            event = Events::Event.new(tag: 'dummy', record: 'dummy record')
+            expect(@buffer.buffer(event)).to eq [event]
+            expect(@buffer.events).to eq [event]
+          end
+
+          it 'should NOT buffer event' do
+            event = Events::Event.new(tag: 'SHOULD NOT BUFFER', record: 'dummy record')
+            @buffer.buffer(event)
+            expect(@buffer.events).to eq []
+          end
+        end
+
+        describe '#source' do
+          subject { @buffer.source }
+
+          it { is_expected.to eq DummyBuffer::DEFAULT_SOURCE }
+
+          context 'with config' do
+            around do |example|
+              @source = 'custom_event'
+
+              ConfigHelper.load_config_yml = <<~CONFIG
+                plugin:
+                 buffers:
+                   dummy_buffer:
+                     source: #{@source}
+              CONFIG
+
+              example.run
+
+              Config.custom_path = nil
+            end
+
+            it { is_expected.to eq @source }
+          end
+        end
+
+        describe '#config_params' do
+          around do |example|
+            ConfigHelper.load_config_yml = <<~CONFIG
+              plugin:
+               buffers:
+                 dummy_buffer:
+                   dummy: dummy
+            CONFIG
+
+            example.run
+
+            Config.custom_path = nil
+          end
+
+          subject { @buffer.config_params }
+          it { is_expected.to eq(dummy: 'dummy') }
+        end
+      end
+    end
+  end
+end

data/spec/lib/plugin/buffers/dummy_buffer.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require './lib/fusuma/plugin/buffers/buffer'
+
+module Fusuma
+  module Plugin
+    module Buffers
+      class DummyBuffer < Buffer
+        DEFAULT_SOURCE = 'dummy'
+
+        def config_param_types
+          {
+            source: String,
+            dummy: String
+          }
+        end
+      end
+    end
+  end
+end

data/spec/lib/plugin/buffers/gesture_buffer_spec.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+require './lib/fusuma/plugin/events/event'
+require './lib/fusuma/plugin/events/records/gesture_record'
+require './lib/fusuma/plugin/buffers/gesture_buffer'
+
+module Fusuma
+  module Plugin
+    module Buffers
+      RSpec.describe GestureBuffer do
+        before do
+          @buffer = GestureBuffer.new
+          delta = Events::Records::GestureRecord::Delta.new(-1, 0, 0, 0, 0, 0)
+          @event_generator = lambda { |time = nil, status = 'updating'|
+            Events::Event.new(time: time,
+                              tag: 'libinput_gesture_parser',
+                              record: Events::Records::GestureRecord.new(
+                                status: status,
+                                gesture: 'SWIPE',
+                                finger: 3,
+                                delta: delta
+                              ))
+          }
+        end
+
+        describe '#type' do
+          it { expect(@buffer.type).to eq 'gesture' }
+        end
+
+        describe '#buffer' do
+          it 'should buffer gesture event' do
+            event = @event_generator.call
+            @buffer.buffer(event)
+            expect(@buffer.events).to eq [event]
+          end
+
+          it 'should NOT buffer other event' do
+            event = Events::Event.new(tag: 'SHOULD NOT BUFFER', record: 'dummy record')
+            @buffer.buffer(event)
+            expect(@buffer.events).to eq []
+          end
+
+          it 'should buffer begin/end' do
+            begin_event = @event_generator.call(nil, 'begin')
+            @buffer.buffer(begin_event)
+            expect(@buffer.events).to eq [begin_event]
+            end_event = @event_generator.call(nil, 'end')
+            @buffer.buffer(end_event)
+            expect(@buffer.events).to eq [begin_event, end_event]
+          end
+        end
+
+        describe '#clear_expired' do
+          it 'should keep only events generated within 30 seconds' do
+            time = Time.now
+            event1 = @event_generator.call(time)
+            @buffer.buffer(event1)
+            event2 = @event_generator.call(time + 100)
+            event3 = @event_generator.call(time + 100)
+            @buffer.buffer(event2)
+            @buffer.buffer(event3)
+
+            @buffer.clear_expired(current_time: time + 100.1)
+
+            expect(@buffer.events).to eq [event2, event3]
+          end
+
+          context 'change seconds to keep' do
+            around do |example|
+              ConfigHelper.load_config_yml = <<~CONFIG
+                plugin:
+                  buffers:
+                    gesture_buffer:
+                      seconds_to_keep: 0.3
+              CONFIG
+
+              example.run
+
+              Config.custom_path = nil
+            end
+
+            it 'should keep only events generated within 0.3 seconds' do
+              expect(@buffer.config_params).to eq(seconds_to_keep: 0.3)
+              time = Time.now
+              event1 = @event_generator.call(time)
+              @buffer.buffer(event1)
+              event2 = @event_generator.call(time + 0.1)
+              @buffer.buffer(event2)
+              event3 = @event_generator.call(time + 0.2)
+              @buffer.buffer(event3)
+              @buffer.clear_expired(current_time: time + 0.29)
+              expect(@buffer.events).to eq [event1, event2, event3]
+
+              @buffer.clear_expired(current_time: time + 0.3)
+              expect(@buffer.events).to eq [event2, event3]
+            end
+          end
+        end
+
+        describe '#source' do
+          it { expect(@buffer.source).to eq GestureBuffer::DEFAULT_SOURCE }
+
+          context 'with config' do
+            around do |example|
+              @source = 'custom_event'
+
+              ConfigHelper.load_config_yml = <<~CONFIG
+                plugin:
+                  buffers:
+                    gesture_buffer:
+                      source: #{@source}
+              CONFIG
+
+              example.run
+
+              Config.custom_path = nil
+            end
+
+            it { expect(@buffer.source).to eq @source }
+          end
+        end
+
+        describe '#sum_attrs' do
+          it 'should calculate the sum of each attribute'
+        end
+
+        describe '#avg_attrs' do
+          it 'should calculate the average of each attribute'
+        end
+
+        describe '#finger' do
+          it 'should return number of fingers in gestures'
+        end
+
+        describe '#gesture' do
+          it 'should return string of gesture type'
+        end
+
+        describe '#empty?' do
+          context 'no gestures in buffer' do
+            before { @buffer.clear }
+            it { expect(@buffer.empty?).to be true }
+          end
+
+          context 'buffered some gestures' do
+            before { @buffer.buffer(@event_generator.call) }
+            it { expect(@buffer.empty?).to be false }
+          end
+        end
+
+        describe '#slect_by_events' do
+          context 'without block' do
+            it { expect(@buffer.select_by_events).to be_a Enumerator }
+          end
+
+          context 'with block' do
+            before do
+              @e1 = @event_generator.call(nil, 'hoge')
+              @e2 = @event_generator.call(nil, 'hoge')
+              @e3 = @event_generator.call(nil, 'fuga')
+              [@e1, @e2, @e3].each { |event| @buffer.buffer(event) }
+            end
+            it { expect(@buffer.select_by_events { |e| e.record.status == 'hoge' }).to be_a GestureBuffer }
+            it { expect(@buffer.select_by_events { |e| e.record.status == 'hoge' }.events).to eq [@e1, @e2] }
+          end
+        end
+      end
+    end
+  end
+end

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
+
+          Config.custom_path = nil
+        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