fusuma 2.1.0 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c964784d9707a4ca667c19b4c866bd5e0abc8e61e2f0752903c2cac3fd064448
-  data.tar.gz: fc9c42d27ee80535d6da10f3cdd0ee707a128ad42f147366dd40f4c2053a273a
+  metadata.gz: 701d329da6fb23d22958f210648a1bf30b73f947064c94c2f30a1ab634edf5e4
+  data.tar.gz: 6335546af4a4624fd450107800b5fde80692f0aa60ab910758be940163006d54
 SHA512:
-  metadata.gz: 99e47419a912ae9e77215fef51bae8bc6a657ac679dbb9a55873087753f354bc9b077657f2fa7699372931ac7a0d0f3faef7d732da4197e1fcef2623b02b8b9c
-  data.tar.gz: 7d8ac348be34c4756e549ac0856fa01119680d5d9ebc7346ca3dc29070023b3a6c8d6a4f2218a3fde6951936d51d8ea0335723dcf2a76285f5ab7a477746ca4e
+  metadata.gz: 931976b9864eb6077a6ebbc34b4425848782cb1b40358ada6e1b2dae6b145bff5382ec61b17ef58835ce1b179be28fca13d76e870243d0f70c40cddb67317700
+  data.tar.gz: 4ccc5737a5ae4d9f979fb409374f3f02c285046f266e368a05c1f5f6e846bfb9ddd47af3bff809f9f6ed1329564aeaaa66b5723ac7e7f342b2031b0322cefbea

data/README.md

@@ -1,4 +1,4 @@
-# Fusuma [![Gem Version](https://badge.fury.io/rb/fusuma.svg)](https://badge.fury.io/rb/fusuma) [![Build Status](https://travis-ci.com/iberianpig/fusuma.svg?branch=master)](https://travis-ci.com/iberianpig/fusuma) [![Coverage Status](https://coveralls.io/repos/github/iberianpig/fusuma/badge.svg?branch=master)](https://coveralls.io/github/iberianpig/fusuma?branch=master)
+# Fusuma [![Gem Version](https://badge.fury.io/rb/fusuma.svg)](https://badge.fury.io/rb/fusuma) [![Testing on Ubuntu](https://github.com/iberianpig/fusuma/actions/workflows/ubuntu.yml/badge.svg)](https://github.com/iberianpig/fusuma/actions/workflows/ubuntu.yml) [![Coverage Status](https://coveralls.io/repos/github/iberianpig/fusuma/badge.svg?branch=master)](https://coveralls.io/github/iberianpig/fusuma?branch=master)
 
 Fusuma is multitouch gesture recognizer.
 This gem makes your linux able to recognize swipes or pinchs and assign commands to them.
@@ -22,13 +22,13 @@ This gem makes your linux able to recognize swipes or pinchs and assign commands
 **IMPORTANT**: You **MUST** be a member of the **INPUT** group to read touchpad by Fusuma.
 
 ```bash
-$ sudo gpasswd -a $USER input
+sudo gpasswd -a $USER input
 ```
 
 Then, You apply the change with no logout or reboot.
 
 ```bash
-$ newgrp input
+newgrp input
 ```
 
 ### For Debian Based Distros (Ubuntu, Debian, Mint, Pop!OS)
@@ -38,7 +38,7 @@ $ newgrp input
 You need `libinput` release 1.0 or later.
 
 ```bash
-$ sudo apt-get install libinput-tools
+sudo apt-get install libinput-tools
 ```
 
 #### 2. Install Ruby
@@ -46,13 +46,13 @@ $ sudo apt-get install libinput-tools
 Fusuma runs in Ruby, so you must install it first.
 
 ```bash
-$ sudo apt-get install ruby
+sudo apt-get install ruby
 ```
 
 #### 3. Install Fusuma
 
 ```bash
-$ sudo gem install fusuma
+sudo gem install fusuma
 ```
 
 #### 4. Install xdotool (optional)
@@ -60,7 +60,7 @@ $ sudo gem install fusuma
 For sending shortcuts:
 
 ```bash
-$ sudo apt-get install xdotool
+sudo apt-get install xdotool
 ```
 
 ### For Arch Based Distros (Manjaro, Arch)
@@ -70,7 +70,7 @@ $ sudo apt-get install xdotool
 You need `libinput` release 1.0 or later. This is most probably installed by default on Manjaro
 
 ```z-h
-$ sudo pacman -S libinput
+sudo pacman -S libinput
 ```
 
 #### 2. Install Ruby
@@ -78,7 +78,7 @@ $ sudo pacman -S libinput
 Fusuma runs in Ruby, so you must install it first.
 
 ```zsh
-$ sudo pacman -S ruby
+sudo pacman -S ruby
 ```
 
 #### 3. Install Fusuma
@@ -88,7 +88,7 @@ $ sudo pacman -S ruby
 To install gems system-wide, see any of the methods listed on [Arch Wiki](https://wiki.archlinux.org/index.php/ruby#Installing_gems_system-wide)
 
 ```zsh
-$ sudo gem install fusuma
+sudo gem install fusuma
 ```
 
 #### 4. Install xdotool (optional)
@@ -96,7 +96,7 @@ $ sudo gem install fusuma
 For sending shortcuts:
 
 ```zsh
-$ sudo pacman -S xdotool
+sudo pacman -S xdotool
 ```
 
 ### Touchpad not working in GNOME
@@ -104,19 +104,19 @@ $ sudo pacman -S xdotool
 Ensure the touchpad events are being sent to the GNOME desktop by running the following command:
 
 ```bash
-$ gsettings set org.gnome.desktop.peripherals.touchpad send-events enabled
+gsettings set org.gnome.desktop.peripherals.touchpad send-events enabled
 ```
 
 ## Usage
 
 ```bash
-$ fusuma
+fusuma
 ```
 
 ## Update
 
 ```bash
-$ sudo gem update fusuma
+sudo gem update fusuma
 ```
 
 ## Customize Gesture Mapping
@@ -125,25 +125,35 @@ You can customize the settings for gestures to put and edit `~/.config/fusuma/co
 **NOTE: You will need to create the `~/.config/fusuma` directory if it doesn't exist yet.**
 
 ```bash
-$ mkdir -p ~/.config/fusuma        # create config directory
-$ nano ~/.config/fusuma/config.yml # edit config file.
+mkdir -p ~/.config/fusuma        # create config directory
+nano ~/.config/fusuma/config.yml # edit config file.
 ```
 
 
 ### Available gestures
 
-* `swipe:`
-  * support `3:`, `4:` fingers
-  * support `left:`, `right:`, `up:`, `down:` directions
-  * support `begin:`, `update:`, `end:` events
-* `pinch:`
-  * support `2:`, `3:`, `4:` fingers
-  * support `in:`, `out:` directions
-  * support `begin:`, `update:`, `end:` events
-* `rotate:`
-  * support `2:`, `3:`, `4:` fingers
-  * support `clockwise:`,`counterclockwise:` directions
-  * support `begin:`, `update:`, `end:` events
+#### swipe:
+
+ * support `3:`, `4:` fingers
+ * support `left:`, `right:`, `up:`, `down:` directions
+ * support `begin:`, `update:`, `end:` events
+
+#### pinch:
+
+ * support `2:`, `3:`, `4:` fingers
+ * support `in:`, `out:` directions
+ * support `begin:`, `update:`, `end:` events
+
+#### rotate:
+
+ * support `2:`, `3:`, `4:` fingers
+ * support `clockwise:`,`counterclockwise:` directions
+ * support `begin:`, `update:`, `end:` events
+
+#### hold:
+ * require libinput version 1.19.0 or later
+ * support `1:`, `2:`, `3:`, `4:` fingers
+ * support `begin:`, `end:`, `cancelled:` events
 
 ### About YAML Basic Syntax
 
@@ -181,6 +191,9 @@ pinch:
     command: "xdotool keydown ctrl click 4 keyup ctrl" # Zoom in
   out:
     command: "xdotool keydown ctrl click 5 keyup ctrl" # Zoom out
+hold:
+  4:
+    command: "xdotool key super" # Activity
 ```
 
 ### More Example of config.yml
@@ -201,12 +214,12 @@ If you have a nice configuration, please share `~/.config/fusuma/config.yml` wit
 
 ### Threshold and Interval
 
-if `command:` properties are blank, the swipe/pinch doesn't execute command.
+if `command:` properties are blank, the swipe/pinch/hold doesn't execute command.
 
-`threshold:` is sensitivity to swipe/pinch. Default value is 1.
+`threshold:` is sensitivity to swipe/pinch/hold. Default value is 1.
 If the swipe's threshold is `0.5`, shorten swipe-length by half.
 
-`interval:` is delay between swipes/pinches. Default value is 1.
+`interval:` is delay between swipes/pinches/hold. Default value is 1.
 If the swipe's interval is `0.5`, shorten swipe-interval by half to recognize a next swipe.
 
 ### Example of `threshold:` / `interval:` settings
@@ -243,7 +256,7 @@ There are three priorities of `threshold:` and `interval:`.
 The individual `threshold:` and `interval:` settings (under "direction") have a higher priority than the global one (under "root")
 
 1. child elements in the direction (left/right/down/up → threshold/interval)
-1. root child elements (threshold/interval → swipe/pinch)
+1. root child elements (threshold/interval → swipe/pinch/hold)
 1. default value (= 1)
 
 ### `command:` property for assigning commands
@@ -314,8 +327,8 @@ plugin:
 
 ## Autostart (gnome-session-properties)
 
-1. Check the path where you installed fusuma with `$ which fusuma`
-2. Open `$ gnome-session-properties`
+1. Check the path where you installed fusuma with `which fusuma`
+2. Open `gnome-session-properties`
 3. Add Fusuma and enter the location where the above path was checked in the command input field
 4. Add the `-d` option at the end of the command input field
 
@@ -327,14 +340,10 @@ Following features are provided as plugins.
 - Features for specific Linux distributions
 - Setting different gestures per applications
 
-### Installation of Fusuma plugins
+### Available plugins
 
 Fusuma plugins are provided with the `fusuma-plugin-XXXXX` naming convention and hosted on [RubyGems](https://rubygems.org/search?utf8=%E2%9C%93&query=fusuma-plugins).
 
-`$ sudo gem install fusuma-plugin-XXXXX`
-
-### Available plugins
-
 | Name                                                                               | Version                                                               | About                                         |
 | ---------------------------------------------------------------------------------- | --------------------------------------------------------------------- | --------------------------------------------- |
 | [fusuma-plugin-sendkey](https://github.com/iberianpig/fusuma-plugin-sendkey)       | ![Gem Version](https://badge.fury.io/rb/fusuma-plugin-sendkey.svg)    | Emulates keyboard events                      |
@@ -343,6 +352,18 @@ Fusuma plugins are provided with the `fusuma-plugin-XXXXX` naming convention and
 | [fusuma-plugin-tap](https://github.com/iberianpig/fusuma-plugin-tap)               | ![Gem Version](https://badge.fury.io/rb/fusuma-plugin-tap.svg)        | Detects Tap and Hold gestures                 |
 | [fusuma-plugin-appmatcher](https://github.com/iberianpig/fusuma-plugin-appmatcher) | ![Gem Version](https://badge.fury.io/rb/fusuma-plugin-appmatcher.svg) | Configure app-specific gestures               |
 
+
+### Installation of Fusuma plugins
+
+```bash
+# install fusuma-plugin-XXXX
+sudo gem install fusuma-plugin-XXXXX`
+```
+```bash
+# update
+sudo gem list fusuma-plugin- | cut -d' ' -f1 | xargs --no-run-if-empty sudo gem update
+```
+
 ## Tutorial Video
 
 [![Multitouch Touchpad Gestures in Linux with Fusuma](http://img.youtube.com/vi/bn11Iwvf29I/0.jpg)](http://www.youtube.com/watch?v=bn11Iwvf29I "Multitouch Touchpad Gestures in Linux with Fusuma")

data/fusuma.gemspec

@@ -20,7 +20,10 @@ Gem::Specification.new do |spec|
   spec.bindir        = 'exe'
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
-  spec.metadata['yard.run'] = 'yri' # use "yard" to build full HTML docs.
+  spec.metadata = {
+    'rubygems_mfa_required' => 'true',
+    'yard.run' => 'yri' # use "yard" to build full HTML docs.
+  }
 
   spec.required_ruby_version = '>= 2.5.1' # https://packages.ubuntu.com/search?keywords=ruby&searchon=names&exact=1&suite=all&section=main
   # support bionic (18.04LTS) 2.5.1

data/lib/fusuma/libinput_command.rb

@@ -13,10 +13,7 @@ module Fusuma
 
     # `libinput-list-devices` and `libinput-debug-events` are deprecated,
     # use `libinput list-devices` and `libinput debug-events` from 1.8.
-    NEW_CLI_OPTION_VERSION = 1.8
-
-    DEFAULT_WAIT_TIME = 0.3
-    TIMEOUT_MESSAGE = 'LIBINPUT TIMEOUT'
+    NEW_CLI_OPTION_VERSION = '1.8'
 
     # @return [Boolean]
     def new_cli_option_available?
@@ -92,10 +89,6 @@ module Fusuma
 
     private
 
-    def wait_time
-      DEFAULT_WAIT_TIME
-    end
-
     # which in ruby: Checking if program exists in $PATH from ruby
     # (https://stackoverflow.com/questions/2108727/which-in-ruby-checking-if-program-exists-in-path-from-ruby)
     # Cross-platform way of finding an executable in the $PATH.

data/lib/fusuma/multi_logger.rb

@@ -11,21 +11,20 @@ module Fusuma
     attr_reader :err_logger
     attr_accessor :debug_mode
 
-    @@filepath = nil
-    def self.filepath=(filepath)
-      @@filepath = filepath
+    class << self
+      attr_writer :filepath
     end
 
     def initialize
-      if @@filepath
-        logfile = File.new(@@filepath, 'a')
+      filepath = self.class.instance_variable_get('@filepath')
+      if filepath
+        logfile = File.new(filepath, 'a')
         super(logfile)
         $stderr = logfile
-        @err_logger = Logger.new($stderr)
       else
         super($stdout)
-        @err_logger = Logger.new($stderr)
       end
+      @err_logger = Logger.new($stderr)
       @debug_mode = false
     end
 

data/lib/fusuma/plugin/buffers/gesture_buffer.rb

@@ -46,7 +46,12 @@ module Fusuma
         def ended?
           return false if empty?
 
-          @events.last.record.status == 'end'
+          case @events.last.record.status
+          when 'end', 'cancelled'
+            true
+          else
+            false
+          end
         end
 
         # @param attr [Symbol]

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

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require_relative './detector'
+
+module Fusuma
+  module Plugin
+    module Detectors
+      # Detect Hold gesture
+      class HoldDetector < Detector
+        SOURCES = %w[gesture timer].freeze
+        BUFFER_TYPE = 'gesture'
+        GESTURE_RECORD_TYPE = 'hold'
+
+        BASE_THERESHOLD = 0.7
+
+        # @param buffers [Array<Buffers::Buffer>]
+        # @return [Events::Event] if event is detected
+        # @return [Array<Events::Event>] if hold end event is detected
+        # @return [NilClass] if event is NOT detected
+        def detect(buffers)
+          hold_buffer = find_hold_buffer(buffers)
+          return if hold_buffer.empty?
+
+          hold_events = hold_buffer.events
+
+          timer_buffer = buffers.find { |b| b.type == 'timer' }
+          timer_events = timer_buffer.events
+
+          finger = hold_buffer.finger
+          holding_time = calc_holding_time(hold_events: hold_events, timer_events: timer_events)
+
+          @timeout ||= nil
+          status = case hold_events.last.record.status
+                   when 'begin'
+                     if holding_time.zero?
+                       'begin'
+                     else
+                       'timer'
+                     end
+                   when 'cancelled'
+                     'cancelled'
+                   when 'end'
+                     'end'
+                   else
+                     last_record = hold_events.last.record.status
+                     raise "Unexpected Status:#{last_record.status} in #{last_record}"
+                   end
+
+          repeat_index = create_repeat_index(finger: finger, status: status)
+          oneshot_index = create_oneshot_index(finger: finger)
+
+          @timeout = nil if status == 'begin'
+
+          if status == 'timer'
+            return if @timeout
+
+            return unless enough?(index: oneshot_index, holding_time: holding_time)
+
+            @timeout = holding_time
+            return create_event(record: Events::Records::IndexRecord.new(
+              index: oneshot_index, trigger: :oneshot
+            ))
+          end
+
+          create_event(record: Events::Records::IndexRecord.new(
+            index: repeat_index, trigger: :repeat
+          ))
+        end
+
+        # @param [Integer] finger
+        # @return [Config::Index]
+        def create_oneshot_index(finger:)
+          Config::Index.new(
+            [
+              Config::Index::Key.new(type),
+              Config::Index::Key.new(finger.to_i)
+            ]
+          )
+        end
+
+        # @param [Integer] finger
+        # @return [Config::Index]
+        def create_repeat_index(finger:, status:)
+          Config::Index.new(
+            [
+              Config::Index::Key.new(type),
+              Config::Index::Key.new(finger.to_i),
+              Config::Index::Key.new(status)
+            ]
+          )
+        end
+
+        private
+
+        # @param buffers [Array<Buffers::Buffer>]
+        # @return [Buffers::GestureBuffer]
+        def find_hold_buffer(buffers)
+          buffers.find { |b| b.type == BUFFER_TYPE }
+                 .select_from_last_begin
+                 .select_by_events { |e| e.record.gesture == GESTURE_RECORD_TYPE }
+        end
+
+        def calc_holding_time(hold_events:, timer_events:)
+          last_time = if !timer_events.empty? && (hold_events.last.time < timer_events.last.time)
+                        timer_events.last.time
+                      else
+                        hold_events.last.time
+                      end
+          last_time - hold_events.first.time
+        end
+
+        def enough?(index:, holding_time:)
+          holding_time > threshold(index: index)
+        end
+
+        def threshold(index:)
+          @threshold ||= {}
+          @threshold[index.cache_key] ||= begin
+            keys_specific = Config::Index.new [*index.keys, 'threshold']
+            keys_global = Config::Index.new ['threshold', type]
+            config_value = Config.search(keys_specific) ||
+                           Config.search(keys_global) || 1
+            BASE_THERESHOLD * config_value
+          end
+        end
+      end
+    end
+  end
+end

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.1.0'
+  VERSION = '2.2.0'
 end

data/spec/lib/libinput_command_spec.rb

@@ -68,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

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/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

data/spec/lib/plugin/parsers/libinput_gesture_parser_spec.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require './lib/fusuma/plugin/parsers/parser'
+require './lib/fusuma/plugin/events/event'
+
+module Fusuma
+  module Plugin
+    module Parsers
+      RSpec.describe LibinputGestureParser do
+        let(:parser) { LibinputGestureParser.new }
+
+        around do |example|
+          ConfigHelper.load_config_yml = <<~CONFIG
+            plugin:
+             parsers:
+               libinput_gesture_parser:
+                 dummy: dummy
+          CONFIG
+
+          example.run
+
+          Config.custom_path = nil
+        end
+
+        describe '#source' do
+          subject { parser.source }
+
+          it { is_expected.to be LibinputGestureParser::DEFAULT_SOURCE }
+        end
+
+        describe '#parse' do
+          context 'with different tag(dummy) event' do
+            let(:event) { Events::Event.new(tag: 'dummy_input', record: 'dummy') }
+            it { expect(parser.parse(event).record).not_to be_a Events::Records::GestureRecord }
+            it { expect(parser.parse(event)).to eq event }
+          end
+
+          context 'with libinput_command_input event' do
+            let(:event) { Events::Event.new(tag: 'libinput_command_input', record: record) }
+            context 'with swipe gestures' do
+              # event10  GESTURE_SWIPE_BEGIN     +0.728s       3
+              # event10  GESTURE_SWIPE_UPDATE    +0.948s       3  0.23/ 0.00 ( 0.29/ 0.00 unaccelerated)
+              # event10  GESTURE_SWIPE_END       +0.989s       3
+              let(:record) { 'event10  GESTURE_SWIPE_BEGIN     +0.728s       3' }
+              it { expect(parser.parse(event).record).to be_a Events::Records::GestureRecord }
+              it { expect(parser.parse(event).record.status).to eq 'begin' }
+            end
+
+            context 'with hold gestures' do
+              # -event10  GESTURE_HOLD_BEGIN      +2.125s       3
+              # event10  GESTURE_HOLD_END        +3.274s       3
+              # event10  GESTURE_HOLD_BEGIN      +5.573s       4
+              # event10  GESTURE_HOLD_END        +6.462s       4 cancelled
+              context 'with begin' do
+                let(:record) { '-event10  GESTURE_HOLD_BEGIN      +2.125s       3' }
+                it { expect(parser.parse(event).record).to be_a Events::Records::GestureRecord }
+                it { expect(parser.parse(event).record.status).to eq 'begin' }
+              end
+              context 'with end' do
+                let(:record) { ' event10  GESTURE_HOLD_END        +3.274s       3' }
+                it { expect(parser.parse(event).record).to be_a Events::Records::GestureRecord }
+                it { expect(parser.parse(event).record.status).to eq 'end' }
+              end
+              context 'with end(cancelled)' do
+                let(:record) { ' event10  GESTURE_HOLD_END        +6.462s       4 cancelled' }
+                it { expect(parser.parse(event).record).to be_a Events::Records::GestureRecord }
+                it { expect(parser.parse(event).record.status).to eq 'cancelled' }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fusuma
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 2.2.0
 platform: ruby
 authors:
 - iberianpig
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-10-01 00:00:00.000000000 Z
+date: 2021-11-21 00:00:00.000000000 Z
 dependencies: []
 description: Fusuma is multitouch gesture recognizer. This gem makes your touchpad
   on Linux able to recognize swipes or pinchs and assign command to them. Read installation
@@ -43,6 +43,7 @@ files:
 - lib/fusuma/plugin/buffers/gesture_buffer.rb
 - lib/fusuma/plugin/buffers/timer_buffer.rb
 - lib/fusuma/plugin/detectors/detector.rb
+- lib/fusuma/plugin/detectors/hold_detector.rb
 - lib/fusuma/plugin/detectors/pinch_detector.rb
 - lib/fusuma/plugin/detectors/rotate_detector.rb
 - lib/fusuma/plugin/detectors/swipe_detector.rb
@@ -56,7 +57,6 @@ files:
 - lib/fusuma/plugin/executors/executor.rb
 - lib/fusuma/plugin/filters/filter.rb
 - lib/fusuma/plugin/filters/libinput_device_filter.rb
-- lib/fusuma/plugin/filters/libinput_timeout_filter.rb
 - lib/fusuma/plugin/inputs/input.rb
 - lib/fusuma/plugin/inputs/libinput_command_input.rb
 - lib/fusuma/plugin/inputs/timer_input.rb
@@ -84,6 +84,7 @@ files:
 - spec/lib/plugin/buffers/gesture_buffer_spec.rb
 - spec/lib/plugin/detectors/detector_spec.rb
 - spec/lib/plugin/detectors/dummy_detector.rb
+- spec/lib/plugin/detectors/hold_detector_spec.rb
 - spec/lib/plugin/detectors/pinch_detector_spec.rb
 - spec/lib/plugin/detectors/rotate_detector_spec.rb
 - spec/lib/plugin/detectors/swipe_detector_spec.rb
@@ -99,12 +100,14 @@ files:
 - spec/lib/plugin/inputs/libinput_command_input_spec.rb
 - spec/lib/plugin/inputs/timer_input_spec.rb
 - spec/lib/plugin/manager_spec.rb
+- spec/lib/plugin/parsers/libinput_gesture_parser_spec.rb
 - spec/lib/plugin/parsers/parser_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/iberianpig/fusuma
 licenses:
 - MIT
 metadata:
+  rubygems_mfa_required: 'true'
   yard.run: yri
 post_install_message: 
 rdoc_options: []
@@ -145,6 +148,7 @@ test_files:
 - spec/lib/plugin/buffers/gesture_buffer_spec.rb
 - spec/lib/plugin/detectors/detector_spec.rb
 - spec/lib/plugin/detectors/dummy_detector.rb
+- spec/lib/plugin/detectors/hold_detector_spec.rb
 - spec/lib/plugin/detectors/pinch_detector_spec.rb
 - spec/lib/plugin/detectors/rotate_detector_spec.rb
 - spec/lib/plugin/detectors/swipe_detector_spec.rb
@@ -160,5 +164,6 @@ test_files:
 - spec/lib/plugin/inputs/libinput_command_input_spec.rb
 - spec/lib/plugin/inputs/timer_input_spec.rb
 - spec/lib/plugin/manager_spec.rb
+- spec/lib/plugin/parsers/libinput_gesture_parser_spec.rb
 - spec/lib/plugin/parsers/parser_spec.rb
 - spec/spec_helper.rb

data/lib/fusuma/plugin/filters/libinput_timeout_filter.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-require_relative './filter'
-require_relative '../../libinput_command'
-
-module Fusuma
-  module Plugin
-    module Filters
-      # Filter device log
-      class LibinputTimeoutFilter < Filter
-        DEFAULT_SOURCE = 'libinput_command_input'
-
-        # @return [TrueClass] when keeping it
-        # @return [FalseClass] when discarding it
-        def keep?(record)
-          record.to_s == LibinputCommand::TIMEOUT_MESSAGE
-        end
-      end
-    end
-  end
-end