fusuma 2.4.0 → 2.5.0

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

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

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

data/spec/lib/plugin/events/records/gesture_record_spec.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require './lib/fusuma/plugin/events/records/gesture_record'
-
-module Fusuma
-  module Plugin
-    module Events
-      module Records
-        RSpec.describe GestureRecord do
-          let(:record) do
-            described_class.new(status: 'updating',
-                                gesture: 'swipe',
-                                finger: 3,
-                                direction: direction)
-          end
-          let(:direction) { GestureRecord::Delta.new(0, 0, 1, 0) }
-        end
-      end
-    end
-  end
-end

data/spec/lib/plugin/events/records/record_spec.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require './lib/fusuma/plugin/events/records/record'
-
-module Fusuma
-  module Plugin
-    module Events
-      module Records
-        RSpec.describe Record do
-          class DummyRecord < Records::Record
-            def type
-              :dummy
-            end
-          end
-          let(:record) { described_class.new }
-
-          describe '#type' do
-            it { expect { record.type }.to raise_error(NotImplementedError) }
-
-            context 'override #type' do
-              let(:record) { DummyRecord.new }
-              it { expect { record.type }.not_to raise_error(NotImplementedError) }
-              it { expect(record.type).to eq :dummy }
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/lib/plugin/events/records/text_record_spec.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require './lib/fusuma/plugin/events/records/text_record'
-
-module Fusuma
-  module Plugin
-    module Events
-      module Records
-        RSpec.describe TextRecord do
-          let(:record) { described_class.new('this is dummy') }
-
-          describe '#type' do
-            subject { record.type }
-            it { is_expected.to eq :text }
-          end
-
-          describe '#to_s' do
-            subject { record.to_s }
-            it { is_expected.to eq 'this is dummy' }
-          end
-        end
-      end
-    end
-  end
-end

data/spec/lib/plugin/executors/command_executor_spec.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require './lib/fusuma/plugin/executors/command_executor'
-require './lib/fusuma/plugin/events/event'
-
-module Fusuma
-  module Plugin
-    module Executors
-      RSpec.describe CommandExecutor do
-        before do
-          index = Config::Index.new([:dummy, 1, :direction])
-          record = Events::Records::IndexRecord.new(index: index)
-          @event = Events::Event.new(tag: 'dummy_detector', record: record)
-          @executor = CommandExecutor.new
-        end
-
-        around do |example|
-          ConfigHelper.load_config_yml = <<~CONFIG
-            dummy:
-              1:
-                direction:
-                  command: 'echo dummy'
-                  interval: 1
-          CONFIG
-
-          example.run
-
-          Config.custom_path = nil
-        end
-
-        describe '#execute' do
-          it 'spawn' do
-            command = 'echo dummy'
-            env = {}
-            expect(Process).to receive(:spawn).with(env, command)
-            expect(Process).to receive(:detach).with(anything)
-            @executor.execute(@event)
-          end
-        end
-
-        describe '#executable?' do
-          context 'detector is matched with config file' do
-            it { expect(@executor.executable?(@event)).to be_truthy }
-          end
-
-          context 'detector is NOT matched with config file' do
-            before do
-              @event.tag = 'invalid'
-            end
-            it { expect(@executor.executable?(@event)).to be_falsey }
-          end
-        end
-      end
-    end
-  end
-end

data/spec/lib/plugin/executors/executor_spec.rb

@@ -1,164 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-require './lib/fusuma/config'
-require './lib/fusuma/plugin/executors/executor'
-require './lib/fusuma/plugin/detectors/detector'
-require './lib/fusuma/plugin/events/event'
-
-module Fusuma
-  module Plugin
-    module Executors
-      RSpec.describe Executor do
-        before { @executor = Executor.new }
-
-        describe '#execute_key' do
-          it { expect { @executor.execute_keys }.to raise_error(NotImplementedError) }
-        end
-
-        describe '#execute' do
-          it { expect { @executor.execute('dummy') }.to raise_error(NotImplementedError) }
-        end
-
-        describe '#executable?' do
-          it { expect { @executor.executable?('dummy') }.to raise_error(NotImplementedError) }
-        end
-      end
-
-      class DummyExecutor < Executor
-        def execute_keys
-          [:dummy]
-        end
-
-        def execute(event)
-          index = Config::Index.new([*event.record.index.keys, :dummy])
-          content = Config.search(index)
-
-          # stdout
-          puts content if executable?(event)
-        end
-
-        def executable?(event)
-          event.tag == 'dummy'
-        end
-      end
-
-      RSpec.describe DummyExecutor do
-        before do
-          index = Config::Index.new([:dummy_gesture,
-                                     Config::Index::Key.new(:dummy_direction, skippable: true)])
-          record = Events::Records::IndexRecord.new(index: index)
-          @event = Events::Event.new(tag: 'dummy', record: record)
-          @executor = DummyExecutor.new
-        end
-
-        around do |example|
-          ConfigHelper.load_config_yml = <<~CONFIG
-            dummy_gesture:
-              dummy_direction:
-                dummy: 'echo dummy'
-                interval: 0.3
-
-            plugin:
-             executors:
-               dummy_executor:
-                 dummy: dummy
-          CONFIG
-
-          example.run
-
-          Config.custom_path = nil
-        end
-
-        describe '#execute' do
-          it { expect { @executor.execute(@event) }.to output("echo dummy\n").to_stdout }
-          context 'without executable' do
-            before do
-              allow(@executor).to receive(:executable?).and_return false
-            end
-            it { expect { @executor.execute(@event) }.not_to output("echo dummy\n").to_stdout }
-          end
-        end
-
-        describe '#executable?' do
-          it { expect(@executor.executable?(@event)).to be_truthy }
-        end
-
-        describe 'interval' do
-          it 'should return interval from Config' do
-            interval_time = 0.3 * DummyExecutor::BASE_ONESHOT_INTERVAL
-            expect(@executor.interval(@event)).to eq interval_time
-          end
-
-          context 'without skippable direction' do
-            around do |example|
-              ConfigHelper.load_config_yml = <<~CONFIG
-                dummy_gesture:
-                  interval: 0.1
-                  dummy_direction:
-                    dummy: 'echo dummy'
-
-                plugin:
-                 executors:
-                   dummy_executor:
-                     dummy: dummy
-              CONFIG
-
-              example.run
-
-              Config.custom_path = nil
-            end
-            it 'should not return parent interval' do
-              expect(@executor.interval(@event)).to eq DummyExecutor::BASE_ONESHOT_INTERVAL
-              expect(@executor.interval(@event)).not_to eq 0.1 * DummyExecutor::BASE_ONESHOT_INTERVAL
-            end
-
-            context 'with Config::Searcher.skip' do
-              it 'should return parent interval' do
-                Config::Searcher.skip do
-                  expect(@executor.interval(@event)).to eq 0.1 * DummyExecutor::BASE_ONESHOT_INTERVAL
-                end
-              end
-            end
-          end
-        end
-
-        describe 'enough_interval?' do
-          it 'should return true at first time' do
-            expect(@executor.enough_interval?(@event)).to eq true
-          end
-
-          context 'after update_interval' do
-            before do
-              @executor.update_interval(@event)
-            end
-            it 'should return false' do
-              expect(@executor.enough_interval?(@event)).to eq false
-            end
-
-            context 'after wait interval time' do
-              before do
-                # dummy_gesture/dummy_direction/interval => 0.3
-                interval_time = 0.3 * DummyExecutor::BASE_ONESHOT_INTERVAL
-
-                @event2 = Events::Event.new(
-                  time: @event.time + interval_time,
-                  tag: 'dummy',
-                  record: @event.record
-                )
-              end
-              it 'should return true after wait' do
-                expect(@executor.enough_interval?(@event2)).to eq true
-              end
-            end
-          end
-        end
-
-        describe '#config_params' do
-          it { expect(@executor.config_params).to eq(dummy: 'dummy') }
-        end
-      end
-    end
-  end
-end

data/spec/lib/plugin/filters/filter_spec.rb

@@ -1,92 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require 'tempfile'
-
-require './lib/fusuma/config'
-require './lib/fusuma/plugin/filters/filter'
-require './lib/fusuma/plugin/events/event'
-
-module Fusuma
-  module Plugin
-    module Filters
-      class DummyFilter < Filter
-        DEFAULT_SOURCE = 'dummy_input'
-
-        def config_param_types
-          {
-            source: String
-          }
-        end
-      end
-
-      RSpec.describe DummyFilter do
-        let(:filter) { DummyFilter.new }
-
-        describe '#source' do
-          subject { filter.source }
-
-          it { is_expected.to eq DummyFilter::DEFAULT_SOURCE }
-
-          context 'with config' do
-            around do |example|
-              @custom_source = 'custom_input'
-
-              ConfigHelper.load_config_yml = <<~CONFIG
-                plugin:
-                 filters:
-                   dummy_filter:
-                     source: #{@custom_source}
-              CONFIG
-
-              example.run
-
-              Config.custom_path = nil
-            end
-
-            it { is_expected.to eq @custom_source }
-          end
-        end
-
-        describe '#filter' do
-          subject { filter.filter(event) }
-          let(:event) { Events::Event.new(tag: 'dummy_input', record: 'dummy') }
-
-          context 'when filter#keep? return false' do
-            before do
-              allow(filter).to receive(:keep?).and_return(false)
-            end
-
-            it { is_expected.to be nil }
-          end
-
-          context 'when filter#keep? return true' do
-            before do
-              allow(filter).to receive(:keep?).and_return(true)
-            end
-
-            it { is_expected.to be event }
-          end
-        end
-
-        describe '#config_params' do
-          around do |example|
-            ConfigHelper.load_config_yml = <<~CONFIG
-              plugin:
-               filters:
-                 dummy_filter:
-                   dummy: dummy
-            CONFIG
-
-            example.run
-
-            Config.custom_path = nil
-          end
-
-          subject { filter.config_params }
-          it { is_expected.to eq(dummy: 'dummy') }
-        end
-      end
-    end
-  end
-end

data/spec/lib/plugin/filters/libinput_filter_spec.rb

@@ -1,120 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require 'tempfile'
-
-require './lib/fusuma/config'
-require './lib/fusuma/plugin/filters/libinput_device_filter'
-require './lib/fusuma/plugin/events/event'
-
-module Fusuma
-  module Plugin
-    module Filters
-      RSpec.describe LibinputDeviceFilter do
-        before do
-          @filter = LibinputDeviceFilter.new
-        end
-
-        describe '#source' do
-          it { expect(@filter.source).to eq LibinputDeviceFilter::DEFAULT_SOURCE }
-
-          context 'with config' do
-            around do |example|
-              @custom_source = 'custom_input'
-
-              ConfigHelper.load_config_yml = <<~CONFIG
-                plugin:
-                 filters:
-                   libinput_device_filter:
-                     source: #{@custom_source}
-              CONFIG
-
-              example.run
-
-              Config.custom_path = nil
-            end
-
-            it { expect(@filter.source).to eq @custom_source }
-          end
-        end
-
-        describe '#filter' do
-          before do
-            @event = Events::Event.new(tag: 'libinput_command_input', record: 'dummy')
-          end
-
-          context 'when filter#keep? return false' do
-            before do
-              allow(@filter).to receive(:keep?).and_return(false)
-            end
-
-            it { expect(@filter.filter(@event)).to be nil }
-          end
-
-          context 'when filter#keep? return true' do
-            before do
-              allow(@filter).to receive(:keep?).and_return(true)
-            end
-
-            it { expect(@filter.filter(@event)).to be @event }
-          end
-        end
-
-        describe '#keep?' do
-          before do
-            device = Device.new(id: 'event18', name: 'Awesome Touchpad', available: true)
-            allow(Device).to receive(:all).and_return([device])
-            @keep_device = LibinputDeviceFilter::KeepDevice.new(name_patterns: [])
-            allow(@filter).to receive(:keep_device).and_return(@keep_device)
-          end
-
-          context 'when including record generated from touchpad' do
-            before do
-              text = ' event18  GESTURE_SWIPE_UPDATE  +1.44s  4 11.23/ 1.00 (36.91/ 3.28 unaccelerated) '
-              @event = Events::Event.new(tag: 'libinput_command_input', record: text)
-            end
-            it 'should keep record' do
-              expect(@filter.keep?(@event.record)).to be true
-            end
-
-            context 'when including -' do
-              before do
-                text = '-event18  GESTURE_SWIPE_UPDATE  +1.44s  4 11.23/ 1.00 (36.91/ 3.28 unaccelerated) '
-                @event = Events::Event.new(tag: 'libinput_command_input', record: text)
-              end
-              it 'should keep record' do
-                expect(@filter.keep?(@event.record)).to be true
-              end
-            end
-          end
-          context 'when new device is added' do
-            before do
-              text = '-event18 DEVICE_ADDED Apple Wireless Trackpad seat0 default group13 cap:pg size 132x112mm tap(dl off) left scroll-nat scroll-2fg-edge click-buttonareas-clickfing '
-              @event = Events::Event.new(tag: 'libinput_command_input', record: text)
-            end
-            it 'should reset KeepDevice' do
-              expect(@keep_device).to receive(:reset)
-              @filter.keep?(@event.record)
-            end
-
-            it 'discard DEVICE_ADDED record' do
-              expect(@filter.keep?(@event.record)).to be false
-            end
-
-            context 'when keep device is NOT matched' do
-              before do
-                @keep_device = LibinputDeviceFilter::KeepDevice.new(name_patterns: ['Microsoft Arc Mouse'])
-                allow(@filter).to receive(:keep_device).and_return(@keep_device)
-              end
-              it 'should NOT reset KeepDevice' do
-                expect(@keep_device).not_to receive(:reset)
-                # NOTE: @event.record is 'Apple Wireless Touchpad'
-                @filter.keep?(@event.record)
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end