fusuma 2.0.0 → 2.0.1

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

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

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

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

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

@@ -0,0 +1,57 @@
+# 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(POSIX::Spawn).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

@@ -0,0 +1,160 @@
+# 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' do
+          it do
+            expect { @executor.execute('dummy') }.to raise_error(NotImplementedError)
+          end
+        end
+
+        describe '#executable?' do
+          it do
+            expect { @executor.executable?('dummy') }.to raise_error(NotImplementedError)
+          end
+        end
+      end
+
+      class DummyExecutor < Executor
+        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