fusuma-plugin-tap 0.4.0.pre → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 17a8597b18f259832d7d6d0dce336d6d9435d000a1adc6656a1dc67b53d3037e
-  data.tar.gz: 5f909eb2fe3be8766cef41235c80710880a51ebde67c0e91e76affe12b000722
+  metadata.gz: 589a25158b72255c93f69c61ca7fdb74e6a489f987eeb8b0fc9df29135dfd89f
+  data.tar.gz: 3138445357bd209a43914f1b5563fced9bd188c2e4d3caf5a5076c2608187fcc
 SHA512:
-  metadata.gz: fe0c32c71db497489620a5ceefbb4ac172c8d7003fe957432f3a779e27ed7ecbe5f4c96c3f23a38f67bc557421d250e0582a729eef31cb00f2b248606826d4f5
-  data.tar.gz: 5f8b2730af48d13f85f4bdf42073669f7d8aea9eb0d2a70f4c521327b2aa1506714c50d80c21fbd3e516ced76cf72015976593a6859b602c71ed38b6df6c534a
+  metadata.gz: 213c141a633f7d172240446177fec600435a58b8dbcfdb7b5f7b6fb8a91616a8444bf1e2beb0df14e25d2474dcd24630e0b42f4c56d6f8d2078c4ce9cb0158a5
+  data.tar.gz: 2fa6133e9b73050f1333f34ba38eb2a4b339c9c8c52abffe7be95f666767c35db256e37dcaaa20aa3a65eeb0811e6e5539d5f8a60ca9b16dda011aaa8f4d28b9

data/README.md

@@ -73,6 +73,49 @@ After checking out the repo, run `bin/setup` to install dependencies. Then, run
 
 To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 
+### Testing with multiple version of libinput
+
+See: [Use latest libinput on fusuma · iberianpig/fusuma Wiki](https://github.com/iberianpig/fusuma/wiki/Use-latest-libinput-on-fusuma)
+
+Install direnv to change the version of libinput from environment variables.
+
+```sh
+sudo apt install direnv
+```
+
+create .envrc
+
+```sh
+touch .envrc
+```
+
+modify .envrc
+```sh
+export LIBINPUT_VERSION=1.17.0
+export LIBINPUT_REPO=/path/to/git/repository/of/libinput
+export LIBINPUT_REPO=/path/to/git/repository/of/libinput
+```
+
+Apply changes `.envrc`
+```sh
+$ direnv allow
+```
+
+Build libinput
+```sh
+$ make build
+```
+
+### Change to pre-built version
+* modify `LIBINPUT_VERSION` in `.envrc` 
+* check version with `$ direnv allow && make version`
+
+### Generate stub of libinput-debug-events for RSpec
+
+```sh
+bundle exec bin/libinput_debug_events_generator.rb
+```
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/iberianpig/fusuma-plugin-tap. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.

data/bin/libinput_debug_events_generator.rb

@@ -4,15 +4,16 @@
 require 'fileutils'
 require 'pathname'
 require 'fusuma/device'
+require 'fusuma/plugin/inputs/libinput_command_input'
 
 # Generate libinput generator
 class LibinputDebugEventsGenerator
   def initialize(evemu_record:)
     @evemu_record = evemu_record
     @gesture_name = Pathname.new(evemu_record).basename
-    @list_devices = ENV.fetch('LIBINPUT_LIST_DEVICES', 'libinput list-devices')
-    @debug_events = ENV.fetch('LIBINPUT_DEBUG_EVENTS', 'libinput debug-events')
-    @libinput_version = ENV.fetch('LIBINPUT_VERSION', 'libinput list-devices')
+    @list_devices = ENV.fetch('LIBINPUT_LIST_DEVICES')
+    @debug_events = ENV.fetch('LIBINPUT_DEBUG_EVENTS')
+    @libinput_version = ENV.fetch('LIBINPUT_VERSION')
   end
 
   def generate_debug_events
@@ -41,6 +42,10 @@ class LibinputDebugEventsGenerator
       rescue Timeout::Error
         puts 'cut out device infos'
       end
+      if `which evemu-play` == ''
+        warn 'evemu-play is not found'
+        exit 1
+      end
 
       command = "evemu-play /dev/input/#{device_id} < #{@evemu_record}"
 

data/fusuma-plugin-tap.gemspec

@@ -16,24 +16,13 @@ Gem::Specification.new do |spec|
   spec.license       = 'MIT'
 
   # Specify which files should be added to the gem when it is released.
-  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
-  spec.files         = Dir.chdir(File.expand_path(__dir__)) do
-    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
-  end
+  spec.files          = Dir['{bin,lib,exe}/**/*', 'LICENSE*', 'README*', '*.gemspec']
+  spec.test_files     = Dir['{test,spec,features}/**/*']
   spec.bindir        = 'exe'
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
   spec.required_ruby_version = '>= 2.3' # https://packages.ubuntu.com/search?keywords=ruby&searchon=names&exact=1&suite=all&section=main
 
-  spec.add_dependency 'fusuma', '~> 2.0.0.pre'
-
-  spec.add_development_dependency 'bundler'
-  spec.add_development_dependency 'github_changelog_generator', '~> 1.14'
-  spec.add_development_dependency 'pry-byebug'
-  spec.add_development_dependency 'rake', '~> 13.0'
-  spec.add_development_dependency 'reek'
-  spec.add_development_dependency 'rspec', '~> 3.0'
-  spec.add_development_dependency 'rubocop'
-  spec.add_development_dependency 'yard'
+  spec.add_dependency 'fusuma', '~> 2.0'
 end

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

@@ -7,6 +7,7 @@ module Fusuma
     module Detectors
       # Detect tap event
       class TapDetector < Detector
+        SOURCES = ['tap', 'gesture', 'timer']
         BUFFER_TYPE = 'tap'
         GESTURE_RECORD_TYPE = 'tap'
 
@@ -126,12 +127,12 @@ module Fusuma
         def interval_time(index:, direction:)
           @interval_time ||= {}
           @interval_time[index.cache_key] ||= begin
-                               keys_specific = Config::Index.new [*index.keys, 'interval']
-                               keys_global = Config::Index.new ['interval', direction]
-                               config_value = Config.search(keys_specific) ||
-                                              Config.search(keys_global) || 1
-                               BASE_INTERVAL * config_value
-                             end
+            keys_specific = Config::Index.new [*index.keys, 'interval']
+            keys_global = Config::Index.new ['interval', direction]
+            config_value = Config.search(keys_specific) ||
+                           Config.search(keys_global) || 1
+            BASE_INTERVAL * config_value
+          end
         end
       end
     end

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

@@ -147,7 +147,7 @@ module Fusuma
           Events::Records::GestureRecord.new(status: status,
                                              gesture: gesture,
                                              finger: finger,
-                                             direction: nil)
+                                             delta: nil)
         end
 
         def tag

data/lib/fusuma/plugin/tap/version.rb

@@ -3,7 +3,7 @@
 module Fusuma
   module Plugin
     module Tap
-      VERSION = '0.4.0.pre'
+      VERSION = '0.4.2'
     end
   end
 end

data/spec/fusuma/plugin/buffers/tap_buffer_spec.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+require 'fusuma/plugin/events/records/gesture_record.rb'
+require 'fusuma/plugin/events/event.rb'
+require 'fusuma/plugin/buffers/buffer.rb'
+
+module Fusuma
+  module Plugin
+    module Buffers
+      RSpec.describe TapBuffer do
+        before do
+          @buffer = TapBuffer.new
+          @event_generator = lambda { |time = nil, finger = 1, status = 'begin'|
+            Events::Event.new(time: time,
+                              tag: 'libinput_tap_parser',
+                              record: Events::Records::GestureRecord.new(
+                                status: status,
+                                gesture: 'tap',
+                                finger: finger,
+                                delta: nil
+                              ))
+          }
+        end
+
+        describe '#type' do
+          it { expect(@buffer.type).to eq 'tap' }
+        end
+
+        describe '#buffer' do
+          it 'should buffer gesture event' do
+            event = @event_generator.call(Time.now)
+            @buffer.buffer(event)
+            expect(@buffer.events).to eq [event]
+          end
+
+          it 'should NOT buffer other event' do
+            event = Events::Event.new(tag: 'SHOULD NOT BUFFER', record: 'dummy record')
+            @buffer.buffer(event)
+            expect(@buffer.events).to eq []
+          end
+        end
+
+        describe '#clear_expired' do
+          context 'with including end' do
+            it 'should NOT clear any events' do
+              time = Time.now
+              event1 = @event_generator.call(time,       1, 'begin')
+              event2 = @event_generator.call(time + 0.1, 2, 'touch')
+              event3 = @event_generator.call(time + 0.2, 1, 'release')
+              event4 = @event_generator.call(time + 0.2, 1, 'end')
+              @buffer.buffer(event1)
+              @buffer.buffer(event2)
+              @buffer.buffer(event3)
+              @buffer.buffer(event4)
+
+              @buffer.clear_expired(current_time: time + 100)
+
+              expect(@buffer.events).to eq []
+            end
+          end
+          context 'WITHOUT including end' do
+            it 'should NOT clear any events' do
+              time = Time.now
+              event1 = @event_generator.call(time,       1, 'begin')
+              event2 = @event_generator.call(time + 0.1, 2, 'touch')
+              event3 = @event_generator.call(time + 0.2, 1, 'release')
+              @buffer.buffer(event1)
+              @buffer.buffer(event2)
+              @buffer.buffer(event3)
+
+              @buffer.clear_expired(current_time: time + 100)
+
+              expect(@buffer.events).to eq [event1, event2, event3]
+            end
+          end
+        end
+
+        describe '#bufferable?' do
+          it 'should buffer first begin event' do
+            time = Time.now
+            event1 = @event_generator.call(time, 1, 'begin')
+            expect(@buffer.bufferable?(event1)).to eq true
+          end
+
+          context 'already exists events in buffer' do
+            before do
+              event2 = @event_generator.call(Time.now, 1, 'begin')
+              @buffer.buffer(event2)
+            end
+            it 'should NOT buffer begin event' do
+              event2 = @event_generator.call(Time.now, 1, 'begin')
+              expect(@buffer.bufferable?(event2)).to eq false
+            end
+
+            it 'should buffer touch event' do
+              event2 = @event_generator.call(Time.now, 2, 'touch')
+              expect(@buffer.bufferable?(event2)).to eq true
+            end
+
+            it 'should buffer release event' do
+              event2 = @event_generator.call(Time.now, 1, 'release')
+              expect(@buffer.bufferable?(event2)).to eq true
+            end
+
+            it 'should buffer end event' do
+              event2 = @event_generator.call(Time.now, 1, 'end')
+              expect(@buffer.bufferable?(event2)).to eq true
+            end
+          end
+        end
+
+        describe '#source' do
+          it { expect(@buffer.source).to eq TapBuffer::DEFAULT_SOURCE }
+
+          context 'with config' do
+            around do |example|
+              @source = 'custom_event'
+
+              ConfigHelper.load_config_yml = <<~CONFIG
+                plugin:
+                  buffers:
+                    tap_buffer:
+                      source: #{@source}
+              CONFIG
+
+              example.run
+
+              Config.custom_path = nil
+            end
+
+            it { expect(@buffer.source).to eq @source }
+          end
+        end
+
+        describe '#finger' do
+          it 'should return number of fingers in gestures' do
+            @buffer.buffer(@event_generator.call(Time.now, 1, 'begin'))
+            expect(@buffer.finger).to eq 1
+            @buffer.buffer(@event_generator.call(Time.now, 2, 'touch'))
+            expect(@buffer.finger).to eq 2
+            @buffer.buffer(@event_generator.call(Time.now, 3, 'touch'))
+            expect(@buffer.finger).to eq 3
+            @buffer.buffer(@event_generator.call(Time.now, 3, 'release'))
+            expect(@buffer.finger).to eq 3
+          end
+        end
+
+        describe '#empty?' do
+          context 'no gestures in buffer' do
+            before { @buffer.clear }
+            it { expect(@buffer.empty?).to be true }
+          end
+
+          context 'buffered some gestures' do
+            before { @buffer.buffer(@event_generator.call(Time.now, 'begin')) }
+            it { expect(@buffer.empty?).to be false }
+          end
+        end
+      end
+    end
+  end
+end

data/spec/fusuma/plugin/detectors/tap_detector_spec.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+require 'fusuma/plugin/detectors/detector.rb'
+require 'fusuma/plugin/buffers/gesture_buffer.rb'
+require 'fusuma/plugin/events/event.rb'
+
+module Fusuma
+  module Plugin
+    module Detectors
+      RSpec.describe TapDetector do
+        before do
+          @detector = TapDetector.new
+          @buffer = Buffers::TapBuffer.new
+          @buffers = [@buffer, Buffers::GestureBuffer.new]
+
+          @event_generator = lambda { |time, finger, status|
+            Events::Event.new(
+              time: time,
+              tag: 'libinput_tap_parser',
+              record: Events::Records::GestureRecord.new(
+                finger: finger,
+                gesture: 'tap',
+                status: status,
+                delta: Events::Records::GestureRecord::Delta.new(0, 0, 0, 0)
+              )
+            )
+          }
+        end
+
+        describe '#detect' do
+          context 'with 1 finger tap events in buffer' do
+            before do
+              [
+                @event_generator.call(Time.now, 1, 'begin'),
+                @event_generator.call(Time.now, 1, 'release')
+              ].each { |event| @buffer.buffer(event) }
+            end
+
+            it 'should generate tap index' do
+              key_symbol = @detector.detect(@buffers).record.index.keys.map(&:symbol)
+              expect(key_symbol).to eq [:tap, 1]
+            end
+          end
+
+          context 'with 2 fingers tap events in buffer' do
+            before do
+              [
+                @event_generator.call(Time.now, 1, 'begin'),
+                @event_generator.call(Time.now, 2, 'touch'),
+                @event_generator.call(Time.now, 2, 'release')
+              ].each { |event| @buffer.buffer(event) }
+            end
+
+            it 'should generate tap index' do
+              key_symbol = @detector.detect(@buffers).record.index.keys.map(&:symbol)
+              expect(key_symbol).to eq [:tap, 2]
+            end
+          end
+
+          context 'with 3 fingers tap events in buffer' do
+            before do
+              time = Time.now
+              [
+                @event_generator.call(time,       1, 'begin'),
+                @event_generator.call(time,       2, 'touch'),
+                @event_generator.call(time,       3, 'touch'),
+                @event_generator.call(time,       3, 'release'),
+                @event_generator.call(time + 0.1, 2, 'release')
+              ].each { |event| @buffer.buffer(event) }
+            end
+
+            it 'should generate tap index' do
+              key_symbol = @detector.detect(@buffers).record.index.keys.map(&:symbol)
+              expect(key_symbol).to eq [:tap, 3]
+            end
+          end
+          context 'with 4 fingers tap events in buffer' do
+            before do
+              time = Time.now
+              [
+                @event_generator.call(time,       1, 'begin'),
+                @event_generator.call(time,       2, 'touch'),
+                @event_generator.call(time,       3, 'touch'),
+                @event_generator.call(time,       4, 'touch'),
+                @event_generator.call(time + 0.1, 4, 'end')
+              ].each { |event| @buffer.buffer(event) }
+            end
+
+            it 'should generate tap index' do
+              key_symbol = @detector.detect(@buffers).record.index.keys.map(&:symbol)
+              expect(key_symbol).to eq [:tap, 4]
+            end
+          end
+
+          context 'with 1 finger hold events in buffer' do
+            before do
+              time = Time.now
+              [
+                @event_generator.call(time,     1, 'begin'),
+                @event_generator.call(time + 2, 1, 'hold')
+              ].each { |event| @buffer.buffer(event) }
+            end
+
+            it 'should generate tap index' do
+              key_symbol = @detector.detect(@buffers).record.index.keys.map(&:symbol)
+              expect(key_symbol).to eq [:hold, 1]
+            end
+          end
+
+          context 'with 2 fingers hold events in buffer' do
+            before do
+              time = Time.now
+              [
+                @event_generator.call(time,     1, 'begin'),
+                @event_generator.call(time,     2, 'touch'),
+                @event_generator.call(time,     2, 'hold'),
+                @event_generator.call(time + 1, 2, 'release')
+              ].each { |event| @buffer.buffer(event) }
+            end
+
+            it 'should generate tap index' do
+              key_symbol = @detector.detect(@buffers).record.index.keys.map(&:symbol)
+              expect(key_symbol).to eq [:hold, 2]
+            end
+          end
+          context 'with 3 fingers hold events in buffer' do
+            before do
+              time = Time.now
+              [
+                @event_generator.call(time,     1, 'begin'),
+                @event_generator.call(time,     2, 'touch'),
+                @event_generator.call(time,     3, 'hold'),
+                @event_generator.call(time,     3, 'release'),
+                @event_generator.call(time + 1, 2, 'release')
+              ].each { |event| @buffer.buffer(event) }
+            end
+
+            it 'should generate hold index' do
+              key_symbol = @detector.detect(@buffers).record.index.keys.map(&:symbol)
+              expect(key_symbol).to eq [:hold, 3]
+            end
+          end
+          context 'with 4 fingers hold events in buffer' do
+            before do
+              time = Time.now
+              [
+                @event_generator.call(time,     1, 'begin'),
+                @event_generator.call(time,     2, 'touch'),
+                @event_generator.call(time,     3, 'touch'),
+                @event_generator.call(time,     4, 'touch'),
+                @event_generator.call(time,     0, 'keep'),
+                @event_generator.call(time,     0, 'keep'),
+                @event_generator.call(time,     0, 'keep'),
+                @event_generator.call(time + 1, 2, 'release')
+              ].each { |event| @buffer.buffer(event) }
+            end
+
+            it 'should generate hold index' do
+              key_symbol = @detector.detect(@buffers).record.index.keys.map(&:symbol)
+              expect(key_symbol).to eq [:hold, 4]
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/fusuma/plugin/parsers/1.10.4/1finger-double-tap.txt

@@ -0,0 +1,15 @@
+event12 - thumb state: THUMB_STATE_MAYBE → THUMB_STATE_NO
+event12 - button state: from BUTTON_STATE_NONE, event BUTTON_EVENT_IN_AREA to BUTTON_STATE_AREA
+event12 - tap state: TAP_STATE_IDLE → TAP_EVENT_TOUCH → TAP_STATE_TOUCH
+event12 - button state: from BUTTON_STATE_AREA, event BUTTON_EVENT_UP to BUTTON_STATE_NONE
+event12 - tap state: TAP_STATE_TOUCH → TAP_EVENT_RELEASE → TAP_STATE_TAPPED
+ event12  POINTER_BUTTON    +5.00s	BTN_LEFT (272) pressed, seat count: 1
+event12 - thumb state: THUMB_STATE_MAYBE → THUMB_STATE_NO
+event12 - button state: from BUTTON_STATE_NONE, event BUTTON_EVENT_IN_AREA to BUTTON_STATE_AREA
+event12 - tap state: TAP_STATE_TAPPED → TAP_EVENT_TOUCH → TAP_STATE_DRAGGING_OR_DOUBLETAP
+event12 - button state: from BUTTON_STATE_AREA, event BUTTON_EVENT_UP to BUTTON_STATE_NONE
+event12 - tap state: TAP_STATE_DRAGGING_OR_DOUBLETAP → TAP_EVENT_RELEASE → TAP_STATE_MULTITAP
+ event12  POINTER_BUTTON    +5.06s	BTN_LEFT (272) released, seat count: 0
+event12 - tap state: TAP_STATE_MULTITAP → TAP_EVENT_TIMEOUT → TAP_STATE_IDLE
+ event12  POINTER_BUTTON    +5.17s	BTN_LEFT (272) pressed, seat count: 1
+ event12  POINTER_BUTTON    +5.21s	BTN_LEFT (272) released, seat count: 0

data/spec/fusuma/plugin/parsers/1.10.4/1finger-hold.txt

@@ -0,0 +1,6 @@
+event12 - thumb state: THUMB_STATE_MAYBE → THUMB_STATE_NO
+event12 - button state: from BUTTON_STATE_NONE, event BUTTON_EVENT_IN_AREA to BUTTON_STATE_AREA
+event12 - tap state: TAP_STATE_IDLE → TAP_EVENT_TOUCH → TAP_STATE_TOUCH
+event12 - tap state: TAP_STATE_TOUCH → TAP_EVENT_TIMEOUT → TAP_STATE_HOLD
+event12 - button state: from BUTTON_STATE_AREA, event BUTTON_EVENT_UP to BUTTON_STATE_NONE
+event12 - tap state: TAP_STATE_HOLD → TAP_EVENT_RELEASE → TAP_STATE_IDLE

data/spec/fusuma/plugin/parsers/1.10.4/1finger-tap.txt

@@ -0,0 +1,8 @@
+event12 - thumb state: THUMB_STATE_MAYBE → THUMB_STATE_NO
+event12 - button state: from BUTTON_STATE_NONE, event BUTTON_EVENT_IN_AREA to BUTTON_STATE_AREA
+event12 - tap state: TAP_STATE_IDLE → TAP_EVENT_TOUCH → TAP_STATE_TOUCH
+event12 - button state: from BUTTON_STATE_AREA, event BUTTON_EVENT_UP to BUTTON_STATE_NONE
+event12 - tap state: TAP_STATE_TOUCH → TAP_EVENT_RELEASE → TAP_STATE_TAPPED
+ event12  POINTER_BUTTON    +5.00s	BTN_LEFT (272) pressed, seat count: 1
+event12 - tap state: TAP_STATE_TAPPED → TAP_EVENT_TIMEOUT → TAP_STATE_IDLE
+ event12  POINTER_BUTTON    +5.07s	BTN_LEFT (272) released, seat count: 0