fusuma 1.10.2 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dddc8b3508264aaa617b19ed621ed6ee97c5f0d8435cb988a29a9789f9fe2a22
-  data.tar.gz: 8c99bd1dbddf7640d9422ed505ac090361b97b87fc0ea77584ddc6fb8f6416db
+  metadata.gz: 0b18c602c00e13b108d71c64d02a04798614bb7b4296cc886127c21a128dafd2
+  data.tar.gz: b4d146e105abd99d5d4cc4f65dee9da5c9e9f1ad35b4c8ca8815ca64664d9a1c
 SHA512:
-  metadata.gz: 107aa86cb7e326e17e7cb5c183e3fcb49a6352fd1f9b6a04211d2820bd6e738b9abb00f2ecddeef31903f2bb77ad15b7dcc742ca835df9eb9f67e970b166e843
-  data.tar.gz: 294b6a9c9fd0770bf470c38af08f5c48fd7fc14d38f3acd0f802ac3f51e21d200de6d02be1f197edea65c0e5d13ee95f4e43a85c8cea0a0a80372154eda3ea15
+  metadata.gz: 4e5bd0ad216bfadd274e3f4a48f96941d27fd80bddf940804228b8a691d8c0180ab7ffd92a2733a3f0e72e5a1ca9ced8797404058cad169aa4a45c3b9ded149d
+  data.tar.gz: f7daa7ba96974bdfa6840d4cc081cf1de3883e10d44e65b7f7370966b7822fc86f39d2dcb1af3ab9b1f385a7c44455da98e4a7cf5811c98fef98f0e759a75e8b

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/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
 
@@ -48,8 +50,6 @@ module Fusuma
       end
 
       def load_custom_config(config_path = nil)
-        return unless config_path
-
         Config.custom_path = config_path
       end
     end
@@ -64,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,7 +1,10 @@
 # frozen_string_literal: true
 
-require_relative './multi_logger.rb'
-require_relative './config/index.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'
 
@@ -9,11 +12,19 @@ require 'yaml'
 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)
@@ -21,14 +32,12 @@ 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
-      reload
     end
 
     def custom_path=(new_path)
@@ -37,40 +46,61 @@ module Fusuma
     end
 
     def reload
-      @cache  = nil
-      @keymap = YAML.load_file(file_path).deep_symbolize_keys
-      MultiLogger.info "reload config : #{file_path}"
+      @searcher = Searcher.new
+      path = find_filepath
+      MultiLogger.info "reload config: #{path}"
+      @keymap = validate(path)
       self
     end
 
+    # @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|
+        MultiLogger.error "#{path}: #{ignored.value} is duplicated"
+        duplicates << duplicate.value
+      end
+      raise InvalidFileError, "Detect duplicate keys #{duplicates}" unless duplicates.empty?
+
+      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
 
-    def file_path
+    def find_filepath
       filename = 'fusuma/config.yml'
-      if custom_path && File.exist?(expand_custom_path)
-        expand_custom_path
+      if custom_path
+        return expand_custom_path if File.exist?(expand_custom_path)
+
+        raise NotFoundError, "#{expand_custom_path} is NOT FOUND"
       elsif File.exist?(expand_config_path(filename))
         expand_config_path(filename)
       else
+        MultiLogger.warn "config file: #{expand_config_path(filename)} is NOT FOUND"
         expand_default_path(filename)
       end
     end
@@ -86,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