fusuma 2.0.3 → 2.2.0

data/lib/fusuma/plugin/detectors/swipe_detector.rb

@@ -24,9 +24,17 @@ module Fusuma
           updating_events = gesture_buffer.updating_events
           return if updating_events.empty?
 
-          updating_time = 100 * (updating_events.last.time - updating_events.first.time)
-          oneshot_move_x = gesture_buffer.sum_attrs(:move_x) / updating_time
-          oneshot_move_y = gesture_buffer.sum_attrs(:move_y) / updating_time
+          oneshot_move_x, oneshot_move_y = if updating_events.size >= 10
+                                             updating_time = 100 * (updating_events[-1].time - updating_events[-10].time)
+                                             last_10 = gesture_buffer.class.new(updating_events[-10..-1])
+                                             [last_10.sum_attrs(:move_x) / updating_time,
+                                              last_10.sum_attrs(:move_y) / updating_time]
+                                           else
+                                             updating_time = 100 * (updating_events.last.time - updating_events.first.time)
+                                             [gesture_buffer.sum_attrs(:move_x) / updating_time,
+                                              gesture_buffer.sum_attrs(:move_y) / updating_time]
+                                           end
+          gesture_buffer.sum_attrs(:move_x) / updating_time
 
           finger = gesture_buffer.finger
           status = case gesture_buffer.events.last.record.status

data/lib/fusuma/plugin/executors/command_executor.rb

@@ -14,19 +14,19 @@ module Fusuma
         end
 
         def execute(event)
-          search_command(event).tap do |command|
-            break unless command
+          command = search_command(event)
 
-            MultiLogger.info(command: command, args: event.record.args)
+          MultiLogger.info(command: command, args: event.record.args)
 
-            accel = args_accel(event)
-            additional_env = event.record.args
-                                  .deep_transform_keys(&:to_s)
-                                  .deep_transform_values { |v| (v * accel).to_s }
+          accel = args_accel(event)
+          additional_env = event.record.args
+                                .deep_transform_keys(&:to_s)
+                                .deep_transform_values { |v| (v * accel).to_s }
 
-            pid = Process.spawn(additional_env, command.to_s)
-            Process.detach(pid)
-          end
+          pid = Process.spawn(additional_env, command.to_s)
+          Process.detach(pid)
+        rescue SystemCallError => e
+          MultiLogger.error("#{event.record.index.keys}": e.message.to_s)
         end
 
         def executable?(event)

data/lib/fusuma/plugin/executors/executor.rb

@@ -15,7 +15,7 @@ module Fusuma
         # @return [Array<Symbol>]
         def execute_keys
           # [name.split('Executors::').last.underscore.gsub('_executor', '').to_sym]
-          raise NotImplementedError, "override #{name}##{__method__}"
+          raise NotImplementedError, "override #{self.class.name}##{__method__}"
         end
 
         # check executable

data/lib/fusuma/plugin/parsers/libinput_gesture_parser.rb

@@ -14,7 +14,7 @@ module Fusuma
         # @return [Records::GestureRecord, nil]
         def parse_record(record)
           case line = record.to_s
-          when /GESTURE_SWIPE|GESTURE_PINCH/
+          when /GESTURE_SWIPE|GESTURE_PINCH|GESTURE_HOLD/
             gesture, status, finger, delta = parse_libinput(line)
           else
             return
@@ -32,13 +32,18 @@ module Fusuma
           _device, event_name, _time, other = line.strip.split(nil, 4)
           finger, other = other.split(nil, 2)
 
+          gesture, status = *detect_gesture(event_name)
+
+          status = 'cancelled' if gesture == 'hold' && status == 'end' && other == 'cancelled'
           delta = parse_delta(other)
-          [*detect_gesture(event_name), finger, delta]
+          [gesture, status, finger, delta]
         end
 
         def detect_gesture(event_name)
-          event_name =~ /GESTURE_(SWIPE|PINCH)_(BEGIN|UPDATE|END)/
-          [Regexp.last_match(1).downcase, Regexp.last_match(2).downcase]
+          event_name =~ /GESTURE_(SWIPE|PINCH|HOLD)_(BEGIN|UPDATE|END)/
+          gesture = Regexp.last_match(1).downcase
+          status = Regexp.last_match(2).downcase
+          [gesture, status]
         end
 
         def parse_delta(line)

data/lib/fusuma/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Fusuma
-  VERSION = '2.0.3'
+  VERSION = '2.2.0'
 end

data/lib/fusuma.rb

@@ -29,6 +29,7 @@ module Fusuma
       end
 
       def read_options(option)
+        MultiLogger.filepath = option[:log_filepath]
         MultiLogger.instance.debug_mode = option[:verbose]
 
         load_custom_config(option[:config_path])
@@ -142,19 +143,26 @@ module Fusuma
       end
       main_events.sort_by! { |e| e.record.trigger_priority }
 
-      condition = nil
+      matched_condition = nil
       matched_context = nil
       event = main_events.find do |main_event|
         matched_context = Config::Searcher.find_context(request_context) do
-          condition, index_record = Config::Searcher.find_condition do
+          matched_condition, modified_record = Config::Searcher.find_condition do
             main_event.record.merge(records: modifiers.map(&:record))
           end
-          main_event if index_record
+          if matched_condition && modified_record
+            main_event.record = modified_record
+          else
+            matched_condition, = Config::Searcher.find_condition do
+              Config.search(main_event.record.index) &&
+                Config.find_execute_key(main_event.record.index)
+            end
+          end
         end
       end
       return if event.nil?
 
-      [condition, matched_context, event]
+      [matched_condition, matched_context, event]
     end
 
     # @param event [Plugin::Events::Event]

data/spec/lib/config/searcher_spec.rb

@@ -7,80 +7,162 @@ require './lib/fusuma/config/searcher'
 # spec for Config
 module Fusuma
   RSpec.describe Config::Searcher do
-    let(:keymap) do
-      {
-        'swipe' => {
-          3 => {
-            'left' => { 'command' => 'alt+Left' },
-            'right' => { 'command' => 'alt+Right' }
-          },
-          4 => {
-            'left' => { 'command' => 'super+Left' },
-            'right' => { 'command' => 'super+Right' }
-          }
-        },
-        'pinch' => {
-          'in' => { 'command' => 'ctrl+plus' },
-          'out' => { 'command' => 'ctrl+minus' }
-        }
-      }
-    end
+    around do |example|
+      ConfigHelper.load_config_yml = <<~CONFIG
+        swipe:
+          3:
+            left:
+              command: 'alt+Left'
+            right:
+              command: 'alt+Right'
+          4:
+            left:
+              command: 'super+Left'
+            right:
+              command: 'super+Right'
+        pinch:
+          in:
+            command: 'ctrl+plus'
+          out:
+            command: 'ctrl+minus'
+      CONFIG
 
-    let(:keymap_without_finger) do
-      {
-        'swipe' => {
-          'left' => { 'command' => 'alt+Left' }
-        }
-      }
-    end
+      example.run
 
-    describe '.custom_path=' do
-      before { Singleton.__init__(Config) }
-      it 'should reload keymap file' do
-        keymap = Config.instance.keymap
-        Config.custom_path = './spec/lib/dummy_config.yml'
-        custom_keymap = Config.instance.keymap
-        expect(keymap).not_to eq custom_keymap
-      end
+      ConfigHelper.clear_config_yml
     end
 
     describe '.search' do
       let(:index) { nil }
-      subject { Config::Searcher.new.search(index, location: keymap.deep_symbolize_keys) }
+      let(:location) { Config.instance.keymap[0] }
+      let(:search) { Config::Searcher.new.search(index, location: location) }
       context 'index correct order' do
         let(:index) { Config::Index.new %w[pinch in command] }
-        it { is_expected.to eq 'ctrl+plus' }
+        it { expect(Config::Searcher.new.search(index, location: location)).to eq 'ctrl+plus' }
       end
 
-      context 'index include skippable key' do
-        let(:index) do
-          Config::Index.new [
-            Config::Index::Key.new('pinch'),
-            Config::Index::Key.new(2, skippable: true),
-            Config::Index::Key.new('out'),
-            Config::Index::Key.new('command')
-          ]
-        end
-        it { expect(Config::Searcher.skip { subject }).to eq 'ctrl+minus' }
+      context 'index incorrect order' do
+        let(:index) { Config::Index.new %w[in pinch 2 command] }
+        it { expect(Config::Searcher.new.search(index, location: location)).not_to eq 'ctrl+plus' }
       end
 
-      context 'index include skippable key at first' do
-        let(:index) do
-          Config::Index.new [
-            Config::Index::Key.new(:hoge, skippable: true),
-            Config::Index::Key.new(:fuga, skippable: true),
-            Config::Index::Key.new('pinch'),
-            Config::Index::Key.new('in'),
-            Config::Index::Key.new(:piyo, skippable: true),
-            Config::Index::Key.new('command')
-          ]
+      context 'with Skip condtions' do
+        context 'when index includes skippable key' do
+          let(:index) do
+            Config::Index.new [
+              Config::Index::Key.new('pinch'),
+              Config::Index::Key.new(2, skippable: true),
+              Config::Index::Key.new('out'),
+              Config::Index::Key.new('command')
+            ]
+          end
+          it 'detects ctrl+minus with skip' do
+            condition, value = Config::Searcher.find_condition do
+              Config::Searcher.new.search(index, location: location)
+            end
+            expect([condition, value]).to eq([:skip, 'ctrl+minus'])
+          end
         end
-        it { expect(Config::Searcher.skip { subject }).to eq 'ctrl+plus' }
-      end
 
-      context 'index incorrect order' do
-        let(:index) { Config::Index.new %w[in pinch 2 command] }
-        it { is_expected.not_to eq 'ctrl+plus' }
+        context 'when index includes skippable key at first' do
+          let(:index) do
+            Config::Index.new [
+              Config::Index::Key.new(:hoge, skippable: true),
+              Config::Index::Key.new(:fuga, skippable: true),
+              Config::Index::Key.new('pinch'),
+              Config::Index::Key.new('in'),
+              Config::Index::Key.new(:piyo, skippable: true),
+              Config::Index::Key.new('command')
+            ]
+          end
+          it 'detects ctrl+plus with skip' do
+            condition, value = Config::Searcher.find_condition do
+              Config::Searcher.new.search(index, location: location)
+            end
+            expect([condition, value]).to eq([:skip, 'ctrl+plus'])
+          end
+        end
+
+        context 'with begin/update/end' do
+          around do |example|
+            ConfigHelper.load_config_yml = <<~CONFIG
+              swipe:
+                3:
+                  begin:
+                    command: 'echo begin'
+                  update:
+                    command: 'echo update'
+                  end:
+                    command: 'echo end'
+                    keypress:
+                      LEFTCTRL:
+                        command: 'echo end+ctrl'
+            CONFIG
+
+            example.run
+
+            ConfigHelper.clear_config_yml
+          end
+
+          context 'without keypress' do
+            let(:index) do
+              Config::Index.new [
+                Config::Index::Key.new(:swipe),
+                Config::Index::Key.new(3),
+                Config::Index::Key.new('left', skippable: true),
+                Config::Index::Key.new('end'),
+                Config::Index::Key.new('command')
+              ]
+            end
+
+            it 'detects with skip' do
+              condition, value = Config::Searcher.find_condition do
+                Config::Searcher.new.search(index, location: location)
+              end
+              expect([condition, value]).to eq([:skip, 'echo end'])
+            end
+          end
+          context 'with keypress' do
+            context 'with valid key existing in config.yml' do
+              let(:index) do
+                Config::Index.new [
+                  Config::Index::Key.new(:swipe),
+                  Config::Index::Key.new(3),
+                  Config::Index::Key.new('left', skippable: true),
+                  Config::Index::Key.new('end'),
+                  Config::Index::Key.new('keypress', skippable: true),
+                  Config::Index::Key.new('LEFTCTRL', skippable: true),
+                  Config::Index::Key.new('command')
+                ]
+              end
+              it 'detects end+ctrl with skip' do
+                condition, value = Config::Searcher.find_condition do
+                  Config::Searcher.new.search(index, location: location)
+                end
+                expect([condition, value]).to eq([:skip, 'echo end+ctrl'])
+              end
+            end
+            context 'with non-existing key not existing in config.yml' do
+              let(:index) do
+                Config::Index.new [
+                  Config::Index::Key.new(:swipe),
+                  Config::Index::Key.new(3),
+                  Config::Index::Key.new('up', skippable: true),
+                  Config::Index::Key.new('end'),
+                  Config::Index::Key.new('keypress', skippable: true),
+                  Config::Index::Key.new('LEFTSHIFT', skippable: true), # Invalid key
+                  Config::Index::Key.new('command')
+                ]
+              end
+              it 'detects end with skip (fallback to no keypress)' do
+                condition, value = Config::Searcher.find_condition do
+                  Config::Searcher.new.search(index, location: location)
+                end
+                expect([condition, value]).to eq([:skip, 'echo end'])
+              end
+            end
+          end
+        end
       end
     end
 

data/spec/lib/config_spec.rb

@@ -25,14 +25,6 @@ module Fusuma
       }
     end
 
-    let(:keymap_without_finger) do
-      {
-        'swipe' => {
-          'left' => { 'command' => 'alt+Left' }
-        }
-      }
-    end
-
     describe '.custom_path=' do
       before { Singleton.__init__(Config) }
       it 'should reload keymap file' do

data/spec/lib/libinput_command_spec.rb

@@ -5,7 +5,9 @@ require './lib/fusuma/libinput_command'
 
 module Fusuma
   RSpec.describe LibinputCommand do
-    let(:libinput_command) { described_class.new(libinput_options: libinput_options, commands: commands) }
+    let(:libinput_command) do
+      described_class.new(libinput_options: libinput_options, commands: commands)
+    end
     let(:libinput_options) { [] }
     let(:commands) { {} }
     describe '#version' do
@@ -66,7 +68,7 @@ module Fusuma
       context 'without NEW_CLI_OPTION_VERSION' do
         before do
           allow(libinput_command).to receive(:version)
-            .and_return(LibinputCommand::NEW_CLI_OPTION_VERSION - 0.1)
+            .and_return('1.7')
         end
         it { is_expected.to eq false }
       end
@@ -79,7 +81,8 @@ module Fusuma
       before do
         dummy_io = StringIO.new('dummy')
         io = StringIO.new('dummy output')
-        allow(Open3).to receive(:popen3).with(anything).and_return([dummy_io, io, dummy_io, dummy_io, nil])
+        allow(Open3).to receive(:popen3).with(anything).and_return([dummy_io, io, dummy_io,
+                                                                    dummy_io, nil])
       end
 
       context 'with the alternative command' do
@@ -119,7 +122,7 @@ module Fusuma
     describe 'debug_events' do
       before do
         @dummy_io = StringIO.new('dummy')
-        allow(Process).to receive(:spawn).with(anything).and_return(0)
+        allow(Process).to receive(:detach).with(anything).and_return(nil)
       end
       subject { libinput_command.debug_events(@dummy_io) }
 
@@ -129,7 +132,8 @@ module Fusuma
         end
 
         it 'should call dummy events' do
-          expect(Process).to receive(:spawn).with('dummy_debug_events', { out: @dummy_io, in: '/dev/null' }).once
+          expect(Process).to receive(:spawn).with('dummy_debug_events',
+                                                  { out: @dummy_io, in: '/dev/null' }).once
           subject
         end
       end

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'spec_helper'
+require 'rspec-parameterized'
 
 require './lib/fusuma/plugin/events/event'
 require './lib/fusuma/plugin/events/records/gesture_record'
@@ -13,7 +14,7 @@ module Fusuma
         before do
           @buffer = GestureBuffer.new
           delta = Events::Records::GestureRecord::Delta.new(-1, 0, 0, 0, 0, 0)
-          @event_generator = lambda { |time = nil, status = 'updating'|
+          @event_generator = lambda { |time = nil, status = 'update'|
             Events::Event.new(time: time,
                               tag: 'libinput_gesture_parser',
                               record: Events::Records::GestureRecord.new(
@@ -53,20 +54,39 @@ module Fusuma
         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]
+          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

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

@@ -27,7 +27,7 @@ module Fusuma
 
           example.run
 
-          Config.custom_path = nil
+          ConfigHelper.clear_config_yml
         end
 
         describe '#detect' do

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

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