fusuma 2.4.1 → 2.5.0

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

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

@@ -1,192 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require 'rspec-parameterized'
-
-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 = 'update'|
-            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
-          context 'default' do
-            before 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)
-            end
-            it 'should keep only events generated within 30 seconds' do
-              @buffer.clear_expired(current_time: @time + 100.1)
-              expect(@buffer.events).to eq [@event2, @event3]
-            end
-            context 'with cancelled or ended' do
-              where(:last_state, :want) do
-                [
-                  ['end',       []],
-                  ['cancelled', []]
-                ]
-              end
-
-              with_them do
-                it 'should clear events' do
-                  event4 = @event_generator.call(@time + 100, last_state)
-                  @buffer.buffer(event4)
-
-                  @buffer.clear_expired(current_time: @time + 100.1)
-                  expect(@buffer.events).to eq want
-                end
-              end
-            end
-          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

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

@@ -1,24 +0,0 @@
-# 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/hold_detector_spec.rb

@@ -1,145 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-require './lib/fusuma/plugin/detectors/hold_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 HoldDetector do
-        before do
-          @detector = HoldDetector.new
-          @buffer = Buffers::GestureBuffer.new
-          @timer_buffer = Buffers::TimerBuffer.new
-        end
-
-        around do |example|
-          ConfigHelper.load_config_yml = <<~CONFIG
-            threshold:
-              hold: 1
-          CONFIG
-
-          example.run
-
-          Config.custom_path = nil
-        end
-
-        describe '#detect' do
-          context 'with no hold event in buffer' do
-            before do
-              @buffer.clear
-            end
-            it { expect(@detector.detect([@buffer, @timer_buffer])).to eq nil }
-          end
-
-          context 'with only hold begin event' do
-            before do
-              events = create_hold_events(statuses: ['begin'])
-              events.each { |event| @buffer.buffer(event) }
-            end
-            it { expect(@detector.detect([@buffer, @timer_buffer])).to be_a Events::Event }
-            it { expect(@detector.detect([@buffer, @timer_buffer]).record).to be_a Events::Records::IndexRecord }
-            it { expect(@detector.detect([@buffer, @timer_buffer]).record.index).to be_a Config::Index }
-            it 'should detect 3 fingers hold' do
-              event = @detector.detect([@buffer, @timer_buffer])
-              expect(event.record.index.keys.map(&:symbol)).to eq([:hold, 3, :begin])
-            end
-          end
-
-          context 'with hold events(begin,cancelled)' do
-            before do
-              events = create_hold_events(statuses: %w[begin cancelled])
-              events.each { |event| @buffer.buffer(event) }
-            end
-            it { expect(@detector.detect([@buffer, @timer_buffer])).to be_a Events::Event }
-            it { expect(@detector.detect([@buffer, @timer_buffer]).record).to be_a Events::Records::IndexRecord }
-            it { expect(@detector.detect([@buffer, @timer_buffer]).record.index).to be_a Config::Index }
-            it 'should detect 3 fingers hold canclled' do
-              event = @detector.detect([@buffer, @timer_buffer])
-              expect(event.record.index.keys.map(&:symbol)).to eq([:hold, 3, :cancelled])
-            end
-          end
-
-          context 'with hold events(begin,end)' do
-            before do
-              events = create_hold_events(statuses: %w[begin end])
-              events.each { |event| @buffer.buffer(event) }
-            end
-            it { expect(@detector.detect([@buffer, @timer_buffer])).to be_a Events::Event }
-            it { expect(@detector.detect([@buffer, @timer_buffer]).record).to be_a Events::Records::IndexRecord }
-            it { expect(@detector.detect([@buffer, @timer_buffer]).record.index).to be_a Config::Index }
-            it 'should detect 3 fingers hold' do
-              events = @detector.detect([@buffer, @timer_buffer])
-              expect(events.record.index.keys.map(&:symbol)).to eq([:hold, 3, :end])
-            end
-          end
-
-          context 'with hold events and timer events' do
-            context 'with begin event and timer events' do
-              before do
-                events = create_hold_events(statuses: %w[begin])
-                events.each { |event| @buffer.buffer(event) }
-                @time = events.last.time
-                @timer_buffer.buffer(create_timer_event(time: @time + HoldDetector::BASE_THERESHOLD))
-              end
-              it { expect(@detector.detect([@buffer, @timer_buffer])).to eq nil }
-
-              context 'with enough holding time' do
-                before do
-                  @timer_buffer.clear
-                  @timer_buffer.buffer(create_timer_event(time: @time + HoldDetector::BASE_THERESHOLD + 0.01))
-                end
-                it { expect(@detector.detect([@buffer, @timer_buffer])).to be_a Events::Event }
-                it { expect(@detector.detect([@buffer, @timer_buffer]).record).to be_a Events::Records::IndexRecord }
-                it { expect(@detector.detect([@buffer, @timer_buffer]).record.index).to be_a Config::Index }
-                it 'should detect 3 fingers hold' do
-                  events = @detector.detect([@buffer, @timer_buffer])
-                  expect(events.record.index.keys.map(&:symbol)).to eq([:hold, 3])
-                end
-              end
-              context 'with changing threshold' do
-                around do |example|
-                  ConfigHelper.load_config_yml = <<~CONFIG
-                    threshold:
-                      hold: 0.9
-                  CONFIG
-
-                  example.run
-
-                  Config.custom_path = nil
-                end
-
-                it { expect(@detector.detect([@buffer, @timer_buffer])).not_to eq nil }
-                it 'should detect 3 fingers hold' do
-                  events = @detector.detect([@buffer, @timer_buffer])
-                  expect(events.record.index.keys.map(&:symbol)).to eq([:hold, 3])
-                end
-              end
-            end
-          end
-        end
-
-        private
-
-        def create_hold_events(statuses:)
-          record_type = HoldDetector::GESTURE_RECORD_TYPE
-          statuses.map do |status|
-            gesture_record = Events::Records::GestureRecord.new(status: status,
-                                                                gesture: record_type,
-                                                                finger: 3,
-                                                                delta: nil)
-            Events::Event.new(tag: 'libinput_gesture_parser', record: gesture_record)
-          end
-        end
-
-        def create_timer_event(time: Time.now)
-          Events::Event.new(time: time, tag: 'timer_input', record: Events::Records::TextRecord.new('timer'))
-        end
-      end
-    end
-  end
-end

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

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

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