fusuma 1.11.1 → 2.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bd9b74b06494e85c0caf6250e0dfeed80c37187098982b4f32c2dd8e727732fb
-  data.tar.gz: eb8c3d19693570b77b26519d7296856480342eec3eba0205ed970e01a4b46a16
+  metadata.gz: 3d8572f753f134496b8ffc0f36c3aafbf142357aad913edd9fd5f5d494d32259
+  data.tar.gz: 6adf4afa35ca59305efa6bde88b2ccf808c3025b5a577cc917d0b32d6b794058
 SHA512:
-  metadata.gz: abe0b55ab9f332d3f67c423b0890135973d57a4cf8b7d6fafc7b01b44874c2489b6752fcb7a66d0b0a625c612879e35ce7d11b6a3b5ce485711b84e8f45e5279
-  data.tar.gz: 323c35769c6f9827f8a94532a4dd10a25facf6bc6858d85b2b6540a6d78064e9003d4ccb83f4914f214aa6523cea8878b5f63abbe113211b1b0900ce0e203521
+  metadata.gz: 68dbe15577eb01891537a573c96ab0a2c532e919588c4fdb62899b236382630d8f575f913c9de282bf9a66b5ae8f91cc820067eedc7ecaa42e839f25d090afd8
+  data.tar.gz: cd74e943167bff03bf2eb1d3eaa9d170f28fd921c3736bcc1a981e49f0c7b755de10ecd8b9b6f314bce76377568441e04cd5228222cfe3c3afd32448569a754c

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.
 
@@ -25,9 +25,15 @@ This gem makes your linux able to recognize swipes or pinchs and assign commands
 $ sudo gpasswd -a $USER input
 ```
 
-Then, You **MUST** **REBOOT** to assign this group.
+Then, You apply the change with no logout or reboot.
 
-### 2. Install libinput-tools
+```bash
+$ newgrp input
+```
+
+### For Debian Based Distros (Ubuntu, Debian, Mint, Pop!OS)
+
+#### 1. Install libinput-tools
 
 You need `libinput` release 1.0 or later.
 
@@ -35,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.
 
@@ -43,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:
 
@@ -57,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:
@@ -242,7 +284,7 @@ swipe:
 - [ydotool](https://github.com/ReimuNotMoe/ydotool)
   - Wayland compatible
   - Needs more maintainers.
-  - Requires only replacing `xdotool` with `ydotool` in in fusuma conf.
+  - Requires only replacing `xdotool` with `ydotool` in fusuma conf.
 
 ## Options
 

data/fusuma.gemspec

@@ -10,29 +10,19 @@ 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.glob('{bin,lib,exe}/**/*') + %w[LICENSE README.md fusuma.gemspec]
+  spec.test_files     = Dir.glob("{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_development_dependency 'bundler'
-  spec.add_development_dependency 'coveralls'
-  spec.add_development_dependency 'github_changelog_generator', '~> 1.14'
-  spec.add_development_dependency 'pry-byebug', '~> 3.4'
-  spec.add_development_dependency 'pry-doc'
-  spec.add_development_dependency 'pry-inline'
-  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.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
+  spec.add_dependency 'posix-spawn'
 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,59 +64,120 @@ module Fusuma
     end
 
     def run
-      # TODO: run with multi thread
-      @inputs.first.run do |event|
-        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
 
-      executor = @executors.find do |e|
-        e.executable?(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
 
-      executor&.execute(event)
+      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,8 +1,10 @@
 # frozen_string_literal: true
 
-require_relative './multi_logger.rb'
-require_relative './config/index.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'
 
@@ -11,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)
@@ -25,12 +32,11 @@ module Fusuma
       end
     end
 
-    attr_reader :keymap
-    attr_reader :custom_path
+    attr_reader :keymap, :custom_path, :searcher
 
     def initialize
+      @searcher = Searcher.new
       @custom_path = nil
-      @cache = nil
       @keymap = nil
     end
 
@@ -40,15 +46,15 @@ module Fusuma
     end
 
     def reload
-      @cache = nil
+      @searcher = Searcher.new
       path = find_filepath
       MultiLogger.info "reload config: #{path}"
       @keymap = validate(path)
       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|
@@ -57,33 +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 context [Hash]
     def search(index)
-      cache(index.cache_key) do
-        index.keys.reduce(keymap) do |location, key|
-          if location.is_a?(Hash)
-            begin
-              if key.skippable
-                location.fetch(key.symbol, location)
-              else
-                location.fetch(key.symbol, nil)
-              end
-            end
-          else
-            location
-          end
-        end
-      end
+      @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
@@ -113,36 +116,5 @@ module Fusuma
     def expand_default_path(filename)
       File.expand_path "../../#{filename}", __FILE__
     end
-
-    def cache(key)
-      @cache ||= {}
-      key = key.join(',') if key.is_a? Array
-      if @cache.key?(key)
-        @cache[key]
-      else
-        @cache[key] = block_given? ? yield : nil
-      end
-    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