fusuma 2.0.0.pre → 2.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bd6d9f73a5476aed954644b4d5f7caa9627779139bc84e301fa2ae67fbb1d71f
-  data.tar.gz: e893683da4aa5f235481ec32bf45a6a2386bc6b64989f36617b6806c538602b3
+  metadata.gz: 5d8b83e60047931022dab6daf54c40da12ec392b638d44c21491528ec7e13bed
+  data.tar.gz: 6e491edb08ad8b2c7f277986cf7d9226663867c1013fec52b04740649e35770d
 SHA512:
-  metadata.gz: 55b7d3393e283bc459b865d293839d6aa2286db4ece74b14d9b50c05726f4d5bfb32609b79541ad816b0ebdebb687b948f03f53fdd1e4d070bf470af56360c84
-  data.tar.gz: f9d5b36287ccd132687497f8f527fc1ef90b0dc818feccf2f9cc6db0b76371a30832467df2d8aa0fca8ee3c5804551da8470b34784c185da73dc08ae507034de
+  metadata.gz: 015112ebf7229f9d48c00735007a598d727bda17e16f4da3b4a6b1d3c8f05ce106d709aabe300414c1232cebc1f52e834fb6cca1961507a60ce6f7528058513a
+  data.tar.gz: c489bd3dbf6c6dd1227e3864abe9c075f6288cf448b8a2b7e85ef092c0586e75b24c76dda16e370ee92bc749fbe378e73bfa376d732dca474cfa43e580af6bfe

data/README.md

@@ -17,7 +17,7 @@ This gem makes your linux able to recognize swipes or pinchs and assign commands
 
 ## Installation
 
-### 1. Grant permission to read the touchpad device
+### Grant permission to read the touchpad device
 
 **IMPORTANT**: You **MUST** be a member of the **INPUT** group to read touchpad by Fusuma.
 
@@ -31,7 +31,9 @@ Then, You apply the change with no logout or reboot.
 $ newgrp input
 ```
 
-### 2. Install libinput-tools
+### For Debian Based Distros (Ubuntu, Debian, Mint, Pop!OS)
+
+#### 1. Install libinput-tools
 
 You need `libinput` release 1.0 or later.
 
@@ -39,7 +41,7 @@ You need `libinput` release 1.0 or later.
 $ sudo apt-get install libinput-tools
 ```
 
-### 3. Install Ruby
+#### 2. Install Ruby
 
 Fusuma runs in Ruby, so you must install it first.
 
@@ -47,13 +49,13 @@ Fusuma runs in Ruby, so you must install it first.
 $ sudo apt-get install ruby
 ```
 
-### 4. Install Fusuma
+#### 3. Install Fusuma
 
 ```bash
 $ sudo gem install fusuma
 ```
 
-### 5. Install xdotool (optional)
+#### 4. Install xdotool (optional)
 
 For sending shortcuts:
 
@@ -61,6 +63,42 @@ For sending shortcuts:
 $ sudo apt-get install xdotool
 ```
 
+### For Arch Based Distros (Manjaro, Arch)
+
+#### 1. Install libinput.
+
+You need `libinput` release 1.0 or later. This is most probably installed by default on Manjaro
+
+```z-h
+$ sudo pacman -S libinput
+```
+
+#### 2. Install Ruby
+
+Fusuma runs in Ruby, so you must install it first.
+
+```zsh
+$ sudo pacman -S ruby
+```
+
+#### 3. Install Fusuma
+
+**Note:** By default in Arch Linux, when running ```gem```, gems are installed per-user (into ```~/.gem/ruby/```), instead of system-wide (into ```/usr/lib/ruby/gems/```). This is considered the best way to manage gems on Arch, because otherwise they might interfere with gems installed by Pacman. (From Arch Wiki)
+
+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
+```
+
+#### 4. Install xdotool (optional)
+
+For sending shortcuts:
+
+```zsh
+$ sudo pacman -S xdotool
+```
+
 ### Touchpad not working in GNOME
 
 Ensure the touchpad events are being sent to the GNOME desktop by running the following command:
@@ -292,12 +330,13 @@ Fusuma plugins are provided with the `fusuma-plugin-XXXXX` naming convention and
 
 ### Available plugins
 
-| Name                                                                           | About                                         |
-| ------------------------------------------------------------------------------ | --------------------------------------------- |
-| [fusuma-plugin-sendkey](https://github.com/iberianpig/fusuma-plugin-sendkey)   | Emulates keyboard events                      |
-| [fusuma-plugin-wmctrl](https://github.com/iberianpig/fusuma-plugin-wmctrl)     | Manages Window and Workspace                  |
-| [fusuma-plugin-keypress](https://github.com/iberianpig/fusuma-plugin-keypress) | Detects gestures while pressing multiple keys |
-| [fusuma-plugin-tap](https://github.com/iberianpig/fusuma-plugin-tap)           | Detects Tap and Hold gestures                 |
+| 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                      |
+| [fusuma-plugin-wmctrl](https://github.com/iberianpig/fusuma-plugin-wmctrl)         | ![Gem Version](https://badge.fury.io/rb/fusuma-plugin-wmctrl.svg)     | Manages Window and Workspace                  |
+| [fusuma-plugin-keypress](https://github.com/iberianpig/fusuma-plugin-keypress)     | ![Gem Version](https://badge.fury.io/rb/fusuma-plugin-keypress.svg)   | Detects gestures while pressing multiple keys |
+| [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               |
 
 ## Tutorial Video
 

data/fusuma.gemspec

@@ -10,19 +10,18 @@ Gem::Specification.new do |spec|
   spec.authors       = ['iberianpig']
   spec.email         = ['yhkyky@gmail.com']
 
-  spec.summary       = 'Multitouch gestures with libinput dirver on X11, Linux'
+  spec.summary       = 'Multitouch gestures with libinput driver, Linux'
   spec.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 on Github(https://github.com/iberianpig/fusuma#installation).'
   spec.homepage      = 'https://github.com/iberianpig/fusuma'
   spec.license       = 'MIT'
 
-  spec.files         = `git ls-files -z`.split("\x0").reject do |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.metadata['yard.run'] = 'yri' # use "yard" to build full HTML docs.
 
-  spec.required_ruby_version = '>= 2.3' # https://packages.ubuntu.com/search?keywords=ruby&searchon=names&exact=1&suite=all&section=main
-  spec.add_dependency 'posix-spawn'
+  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
 end

data/lib/fusuma.rb

@@ -2,10 +2,10 @@
 
 require_relative './fusuma/version'
 require_relative './fusuma/multi_logger'
-require_relative './fusuma/config.rb'
-require_relative './fusuma/environment.rb'
-require_relative './fusuma/device.rb'
-require_relative './fusuma/plugin/manager.rb'
+require_relative './fusuma/config'
+require_relative './fusuma/environment'
+require_relative './fusuma/device'
+require_relative './fusuma/plugin/manager'
 
 # this is top level module
 module Fusuma
@@ -16,6 +16,8 @@ module Fusuma
         set_trap
         read_options(option)
         instance = new
+        ## NOTE: Uncomment following line to measure performance
+        # instance.run_with_lineprof
         instance.run
       end
 
@@ -62,68 +64,120 @@ module Fusuma
     end
 
     def run
-      loop do
-        event = input
-        event || next
-        clear_expired_events
-        filtered = filter(event) || next
-        parsed = parse(filtered) || next
-        buffered = buffer(parsed) || next
-        detected = detect(buffered) || next
-        merged = merge(detected) || next
-        execute(merged)
+      loop { pipeline }
+    end
+
+    def pipeline
+      event = input || return
+      clear_expired_events
+      filtered = filter(event) || return
+      parsed = parse(filtered) || return
+      buffered = buffer(parsed) || return
+      detected = detect(buffered) || return
+      condition, context, event = merge(detected) || return
+      execute(condition, context, event)
+    end
+
+    # For performance monitoring
+    def run_with_lineprof(count: 1000)
+      require 'rblineprof'
+      require 'rblineprof-report'
+
+      profile = lineprof(%r{#{Pathname.new(__FILE__).parent}/.}) do
+        count.times { pipeline }
       end
+      LineProf.report(profile)
+      exit 0
     end
 
+    # @return [Plugin::Events::Event]
     def input
       Plugin::Inputs::Input.select(@inputs)
     end
 
+    # @param [Plugin::Events::Event]
+    # @return [Plugin::Events::Event]
     def filter(event)
       event if @filters.any? { |f| f.filter(event) }
     end
 
+    # @param [Plugin::Events::Event]
+    # @return [Plugin::Events::Event]
     def parse(event)
       @parsers.reduce(event) { |e, p| p.parse(e) if e }
     end
 
+    # @param [Plugin::Events::Event]
+    # @return [Array<Plugin::Buffers::Buffer>]
+    # @return [NilClass]
     def buffer(event)
-      @buffers.any? { |b| b.buffer(event) } && @buffers
+      @buffers.select { |b| b.buffer(event) }
     end
 
     # @param buffers [Array<Buffer>]
     # @return [Array<Event>]
     def detect(buffers)
-      @detectors.each_with_object([]) do |detector, detected|
-        if (event = detector.detect(buffers))
-          detected << event
-        end
+      matched_detectors = @detectors.select do |detector|
+        detector.watch? ||
+          buffers.any? { |b| detector.sources.include?(b.type) }
+      end
+
+      events = matched_detectors.each_with_object([]) do |detector, detected|
+        Array(detector.detect(@buffers)).each { |e| detected << e }
       end
+
+      return if events.empty?
+
+      events
     end
 
-    # @param events [Array<Event>]
-    # @return [Event] a Event merged all records from arguments
+    # @param events [Array<Plugin::Events::Event>]
+    # @return [Plugin::Events::Event] Event merged all records from arguments
     # @return [NilClass] when event is NOT given
     def merge(events)
-      main_events, modifiers = events.partition { |event| event.record.mergable? }
-      return nil unless (main_event = main_events.first)
+      index_events, context_events = events.partition { |event| event.record.type == :index }
+      main_events, modifiers = index_events.partition { |event| event.record.mergable? }
+      request_context = context_events.each_with_object({}) do |e, results|
+        results[e.record.name] = e.record.value
+      end
+      main_events.sort_by! { |e| e.record.trigger_priority }
+
+      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
+            main_event.record.merge(records: modifiers.map(&:record))
+          end
+          main_event if index_record
+        end
+      end
+      return if event.nil?
 
-      main_event.record.merge(records: modifiers.map(&:record))
-      main_event
+      [condition, matched_context, event]
     end
 
-    def execute(event)
+    # @param event [Plugin::Events::Event]
+    def execute(condition, context, event)
       return unless event
 
-      l = lambda do
-        executor = @executors.find { |e| e.executable?(event) }
-        executor&.execute(event)
+      # Find executable condition and executor
+      executor = Config::Searcher.with_context(context) do
+        Config::Searcher.with_condition(condition) do
+          @executors.find { |e| e.executable?(event) }
+        end
       end
 
-      l.call ||
-        Config::Searcher.skip { l.call } ||
-        Config::Searcher.fallback { l.call } ||
-        Config::Searcher.skip { Config::Searcher.fallback { l.call } }
+      return if executor.nil?
+
+      # Check interval and execute
+      Config::Searcher.with_context(context) do
+        Config::Searcher.with_condition(condition) do
+          executor.enough_interval?(event) &&
+            executor.update_interval(event) &&
+            executor.execute(event)
+        end
+      end
     end
 
     def clear_expired_events

data/lib/fusuma/config.rb

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
 
-require_relative './multi_logger.rb'
-require_relative './config/index.rb'
-require_relative './config/searcher.rb'
-require_relative './config/yaml_duplication_checker.rb'
+require_relative './multi_logger'
+require_relative './config/index'
+require_relative './config/searcher'
+require_relative './config/yaml_duplication_checker'
+require_relative './hash_support'
 require 'singleton'
 require 'yaml'
 
@@ -12,13 +13,18 @@ module Fusuma
   # read keymap from yaml file
   class Config
     class NotFoundError < StandardError; end
+
     class InvalidFileError < StandardError; end
 
     include Singleton
 
     class << self
-      def search(keys)
-        instance.search(keys)
+      def search(index)
+        instance.search(index)
+      end
+
+      def find_execute_key(index)
+        instance.find_execute_key(index)
       end
 
       def custom_path=(new_path)
@@ -26,9 +32,7 @@ module Fusuma
       end
     end
 
-    attr_reader :keymap
-    attr_reader :custom_path
-    attr_reader :searcher
+    attr_reader :keymap, :custom_path, :searcher
 
     def initialize
       @searcher = Searcher.new
@@ -49,8 +53,8 @@ module Fusuma
       self
     end
 
-    # @return [Hash]
-    # @raise [InvalidError]
+    # @return [Hash] If check passes
+    # @raise [InvalidFileError] If check does not pass
     def validate(path)
       duplicates = []
       YAMLDuplicationChecker.check(File.read(path), path) do |ignored, duplicate|
@@ -59,20 +63,30 @@ module Fusuma
       end
       raise InvalidFileError, "Detect duplicate keys #{duplicates}" unless duplicates.empty?
 
-      yaml = YAML.load_file(path)
-
-      raise InvalidFileError, 'Invaid YAML file' unless yaml.is_a? Hash
-
-      yaml.deep_symbolize_keys
+      yamls = YAML.load_stream(File.read(path)).compact
+      yamls.map(&:deep_symbolize_keys)
     rescue StandardError => e
       MultiLogger.error e.message
       raise InvalidFileError, e.message
     end
 
     # @param index [Index]
-    # @param location [Hash]
-    def search(index, location: keymap)
-      @searcher.search_with_cache(index, location: location)
+    # @param context [Hash]
+    def search(index)
+      @searcher.search_with_cache(index, location: keymap)
+    end
+
+    # @param index [Config::Index]
+    # @return Symbol
+    def find_execute_key(index)
+      @execute_keys ||= Plugin::Executors::Executor.plugins.map do |executor|
+        executor.new.execute_keys
+      end.flatten
+
+      execute_params = search(index)
+      return if execute_params.nil?
+
+      @execute_keys.find { |k| execute_params.keys.include?(k) }
     end
 
     private
@@ -104,24 +118,3 @@ module Fusuma
     end
   end
 end
-
-# activesupport-4.1.1/lib/active_support/core_ext/hash/keys.rb
-class Hash
-  def deep_symbolize_keys
-    deep_transform_keys do |key|
-      begin
-        key.to_sym
-      rescue StandardError
-        key
-      end
-    end
-  end
-
-  def deep_transform_keys(&block)
-    result = {}
-    each do |key, value|
-      result[yield(key)] = value.is_a?(Hash) ? value.deep_transform_keys(&block) : value
-    end
-    result
-  end
-end

data/lib/fusuma/config/index.rb

@@ -19,6 +19,11 @@ module Fusuma
                   [Key.new(keys)]
                 end
       end
+
+      def inspect
+        @keys.map(&:inspect)
+      end
+
       attr_reader :keys
 
       def cache_key
@@ -32,23 +37,44 @@ module Fusuma
         end
       end
 
+      # @return [Index]
+      def with_context
+        keys = @keys.map do |key|
+          next if Searcher.skip? && key.skippable
+
+          if Searcher.fallback? && key.fallback
+            key.fallback
+          else
+            key
+          end
+        end
+        self.class.new(keys.compact)
+      end
+
       # Keys in Index
       class Key
         def initialize(symbol_word, skippable: false, fallback: nil)
           @symbol = begin
-                      symbol_word.to_sym
-                    rescue StandardError
-                      symbol_word
-                    end
+            symbol_word.to_sym
+          rescue StandardError
+            symbol_word
+          end
 
           @skippable = skippable
 
           @fallback = begin
-                        fallback.to_sym
-                      rescue StandardError
-                        fallback
-                      end
+            fallback.to_sym
+          rescue StandardError
+            fallback
+          end
         end
+
+        def inspect
+          skip_marker = @skippable && Searcher.skip? ? '(skip)' : ''
+          fallback_marker = @fallback && Searcher.fallback? ? '(fallback)' : ''
+          "#{@symbol}#{skip_marker}#{fallback_marker}"
+        end
+
         attr_reader :symbol, :skippable, :fallback
       end
     end