fusuma 2.5.1 → 3.1.0

data/lib/fusuma/plugin/inputs/input.rb

@@ -9,8 +9,14 @@ module Fusuma
       # Inherite this base
       # @abstract Subclass and override {#io} to implement
       class Input < Base
+        def initialize(*args)
+          super(*args)
+          @tag = self.class.name.split("Inputs::").last.underscore
+        end
+
+        attr_reader :tag
+
         # Wait multiple inputs until it becomes readable
-        # and read lines with nonblock
         # @param inputs [Array<Input>]
         # @return [Event]
         def self.select(inputs)
@@ -20,20 +26,17 @@ module Fusuma
           input = inputs.find { |i| i.io == io }
 
           begin
-            line = io.readline_nonblock("\n").chomp
+            # NOTE: io.readline is blocking method
+            # each input plugin must write line to pipe (include `\n`)
+            line = io.readline(chomp: true)
           rescue EOFError => e
-            warn "#{input.class.name}: #{e}"
-            warn "Send SIGKILL to fusuma processes"
-            inputs.reject { |i| i == input }.each do |i|
-              warn "stop process: #{i.class.name.underscore}"
-              Process.kill(:SIGKILL, i.pid)
-            end
-            exit 1
+            MultiLogger.error "#{input.class.name}: #{e}"
+            MultiLogger.error "Shutdown fusuma process..."
+            Process.kill("TERM", Process.pid)
           rescue => e
-            warn "#{input.class.name}: #{e}"
+            MultiLogger.error "#{input.class.name}: #{e}"
             exit 1
           end
-
           input.create_event(record: line)
         end
 
@@ -53,32 +56,7 @@ module Fusuma
           MultiLogger.debug(input_event: e)
           e
         end
-
-        def tag
-          self.class.name.split("Inputs::").last.underscore
-        end
       end
     end
   end
 end
-
-# ref: https://github.com/Homebrew/brew/blob/6b2dbbc96f7d8aa12f9b8c9c60107c9cc58befc4/Library/Homebrew/extend/io.rb
-class IO
-  def readline_nonblock(sep = $INPUT_RECORD_SEPARATOR)
-    line = +""
-    buffer = +""
-
-    loop do
-      break if buffer == sep
-
-      read_nonblock(1, buffer)
-      line.concat(buffer)
-    end
-
-    line.freeze
-  rescue IO::WaitReadable, EOFError => e
-    raise e if line.empty?
-
-    line.freeze
-  end
-end

data/lib/fusuma/plugin/inputs/libinput_command_input.yml

@@ -0,0 +1,3 @@
+plugin:
+  inputs:
+    libinput_command_input:

data/lib/fusuma/plugin/inputs/timer_input.rb

@@ -1,20 +1,29 @@
 # frozen_string_literal: true
 
 require_relative "./input"
+require "timeout"
 
 module Fusuma
   module Plugin
     module Inputs
       # libinput commands wrapper
       class TimerInput < Input
-        DEFAULT_INTERVAL = 0.3
+        include Singleton
+        DEFAULT_INTERVAL = 5
+        EPSILON_TIME = 0.02
         def config_param_types
           {
             interval: [Float]
           }
         end
 
-        attr_reader :pid
+        def initialize(*args, interval: nil)
+          super(*args)
+          @interval = interval || config_params(:interval) || DEFAULT_INTERVAL
+          @early_wake_queue = Queue.new
+        end
+
+        attr_reader :pid, :interval
 
         def io
           @io ||= begin
@@ -26,26 +35,36 @@ module Fusuma
         end
 
         def start(reader, writer)
-          pid = fork do
-            timer_loop(reader, writer)
+          Thread.new do
+            timer_loop(writer)
           end
-          Process.detach(pid)
-          writer.close
-          pid
+          nil
         end
 
-        def timer_loop(reader, writer)
-          reader.close
-          begin
-            loop do
-              sleep interval
-              writer.puts "timer"
+        def timer_loop(writer)
+          delta_t = @interval
+          next_wake = Time.now + delta_t
+          loop do
+            sleep_time = next_wake - Time.now
+            if sleep_time <= 0
+              raise Timeout::Error
+            end
+
+            Timeout.timeout(sleep_time) do
+              next_wake = [@early_wake_queue.deq, next_wake].min
             end
-          rescue Errno::EPIPE
-            exit 0
-          rescue => e
-            MultiLogger.error e
+          rescue Timeout::Error
+            writer.puts "timer"
+            next_wake = Time.now + delta_t
           end
+        rescue Errno::EPIPE
+          exit 0
+        rescue => e
+          MultiLogger.error e
+        end
+
+        def wake_early(t)
+          @early_wake_queue.push(t + EPSILON_TIME)
         end
 
         private
@@ -53,10 +72,6 @@ module Fusuma
         def create_io
           IO.pipe
         end
-
-        def interval
-          config_params(:interval) || DEFAULT_INTERVAL
-        end
       end
     end
   end

data/lib/fusuma/plugin/manager.rb

@@ -27,29 +27,34 @@ module Fusuma
         @_fusuma_default_plugin_paths ||= Dir.glob(File.expand_path("#{__dir__}/../../#{search_key}")).grep_v(exclude_path_pattern).sort
       end
 
+      # @return [Array<String>] paths of external plugins (installed by gem)
       def fusuma_external_plugin_paths
         @_fusuma_external_plugin_paths ||=
           Gem.find_latest_files(search_key).map do |siblings_plugin|
             next unless %r{fusuma-plugin-(.+).*/lib/#{plugin_dir_name}/.+\.rb}.match?(siblings_plugin)
 
             match_data = siblings_plugin.match(%r{(.*)/(.*)/lib/(.*)})
-            gemspec_path = Dir.glob("#{match_data[1]}/#{match_data[2]}/*.gemspec").first
-            raise "Not Found: #{match_data[1]}/#{match_data[2]}/*.gemspec" unless gemspec_path
+            plugin_gemspec_path = Dir.glob("#{match_data[1]}/#{match_data[2]}/*.gemspec").first
+            raise "Not Found: #{match_data[1]}/#{match_data[2]}/*.gemspec" unless plugin_gemspec_path
 
-            gemspec = Gem::Specification.load(gemspec_path)
+            plugin_gemspec = Gem::Specification.load(plugin_gemspec_path)
             fusuma_gemspec_path = File.expand_path("../../../fusuma.gemspec", __dir__)
             fusuma_gemspec = Gem::Specification.load(fusuma_gemspec_path)
 
-            if gemspec.dependencies.find { |d| d.name == "fusuma" }&.match?(fusuma_gemspec)
+            if plugin_gemspec.dependencies.find { |d| d.name == "fusuma" }&.match?(fusuma_gemspec)
               siblings_plugin
             else
-              MultiLogger.warn "#{gemspec.name} #{gemspec.version} is incompatible with running #{fusuma_gemspec.name} #{fusuma_gemspec.version}"
-              MultiLogger.warn "gemspec: #{gemspec_path}"
+              MultiLogger.warn "#{plugin_gemspec.name} #{plugin_gemspec.version} is incompatible with running #{fusuma_gemspec.name} #{fusuma_gemspec.version}"
+              MultiLogger.warn "gemspec: #{plugin_gemspec_path}"
               next
             end
           end.compact.grep_v(exclude_path_pattern).sort
       end
 
+      # @return [String] search key for plugin
+      # @example
+      # search_key
+      # => "fusuma/plugin/detectors/*rb"
       def search_key
         File.join(plugin_dir_name, "*rb")
       end
@@ -110,6 +115,12 @@ module Fusuma
           @plugins ||= {}
         end
 
+        # @return [Array<String>]
+        # @example
+        #   Manager.load_paths
+        #   => ["/path/to/fusuma/lib/fusuma/plugin/inputs/input.rb",
+        #       "/path/to/fusuma/lib/fusuma/plugin/inputs/libinput_command_input.rb",
+        #       "/path/to/fusuma/lib/fusuma/plugin/inputs/timer_input.rb"]
         def load_paths
           @load_paths ||= []
         end

data/lib/fusuma/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Fusuma
-  VERSION = "2.5.1"
+  VERSION = "3.1.0"
 end

data/lib/fusuma.rb

@@ -13,9 +13,9 @@ module Fusuma
   class Runner
     class << self
       def run(option = {})
-        set_trap
         read_options(option)
         instance = new
+        instance.set_trap
         ## NOTE: Uncomment following line to measure performance
         # instance.run_with_lineprof
         instance.run
@@ -23,22 +23,22 @@ module Fusuma
 
       private
 
-      def set_trap
-        Signal.trap("INT") { puts exit } # Trap ^C
-        Signal.trap("TERM") { puts exit } # Trap `Kill `
-      end
-
       def read_options(option)
         MultiLogger.filepath = option[:log_filepath]
         MultiLogger.instance.debug_mode = option[:verbose]
 
-        load_custom_config(option[:config_path])
-
         Plugin::Manager.require_base_plugins
 
+        load_custom_config(option[:config_path])
+
         Environment.dump_information
         Kernel.exit(0) if option[:version]
 
+        if option[:show_config]
+          Environment.print_config
+          Kernel.exit(0)
+        end
+
         if option[:list]
           Environment.print_device_list
           Kernel.exit(0)
@@ -56,7 +56,9 @@ module Fusuma
     end
 
     def initialize
-      @inputs = Plugin::Inputs::Input.plugins.map(&:new)
+      @inputs = Plugin::Inputs::Input.plugins.map do |cls|
+        cls.ancestors.include?(Singleton) ? cls.instance : cls.new
+      end
       @filters = Plugin::Filters::Filter.plugins.map(&:new)
       @parsers = Plugin::Parsers::Parser.plugins.map(&:new)
       @buffers = Plugin::Buffers::Buffer.plugins.map(&:new)
@@ -75,8 +77,8 @@ module Fusuma
       parsed = parse(filtered) || return
       buffered = buffer(parsed) || return
       detected = detect(buffered) || return
-      condition, context, event = merge(detected) || return
-      execute(condition, context, event)
+      context, event = merge(detected) || return
+      execute(context, event)
     end
 
     # For performance monitoring
@@ -98,12 +100,14 @@ module Fusuma
 
     # @param [Plugin::Events::Event]
     # @return [Plugin::Events::Event]
+    # @return [NilClass]
     def filter(event)
       event if @filters.any? { |f| f.filter(event) }
     end
 
     # @param [Plugin::Events::Event]
     # @return [Plugin::Events::Event]
+    # @return [NilClass]
     def parse(event)
       @parsers.reduce(event) { |e, p| p.parse(e) if e }
     end
@@ -117,6 +121,7 @@ module Fusuma
 
     # @param buffers [Array<Buffer>]
     # @return [Array<Event>]
+    # @return [NilClass]
     def detect(buffers)
       matched_detectors = @detectors.select do |detector|
         detector.watch? ||
@@ -124,7 +129,8 @@ module Fusuma
       end
 
       events = matched_detectors.each_with_object([]) do |detector, detected|
-        Array(detector.detect(@buffers)).each { |e| detected << e }
+        # Array(detector.detect(@buffers)).each { |e| detected << e }
+        detected.concat(Array(detector.detect(@buffers)))
       end
 
       return if events.empty?
@@ -133,7 +139,7 @@ module Fusuma
     end
 
     # @param events [Array<Plugin::Events::Event>]
-    # @return [Plugin::Events::Event] Event merged all records from arguments
+    # @return [Array<Hash, Plugin::Events::Event>] Event merged all events from arguments and used context
     # @return [NilClass] when event is NOT given
     def merge(events)
       index_events, context_events = events.partition { |event| event.record.type == :index }
@@ -143,44 +149,34 @@ module Fusuma
       end
       main_events.sort_by! { |e| e.record.trigger_priority }
 
-      matched_condition = nil
       matched_context = nil
       event = main_events.find do |main_event|
         matched_context = Config::Searcher.find_context(request_context) do
-          matched_condition, modified_record = Config::Searcher.find_condition do
-            main_event.record.merge(records: modifiers.map(&:record))
-          end
-          if matched_condition && modified_record
+          if (modified_record = main_event.record.merge(records: modifiers.map(&:record)))
             main_event.record = modified_record
-          else
-            matched_condition, = Config::Searcher.find_condition do
-              Config.search(main_event.record.index) &&
-                Config.find_execute_key(main_event.record.index)
-            end
+          elsif !modifiers.empty?
+            # try basically the same, but without any modifiers
+            # if modifiers is empty then we end up here only if there is no execute key for this
+            Config.instance.search(main_event.record.index) &&
+              Config.instance.find_execute_key(main_event.record.index)
           end
         end
       end
       return if event.nil?
 
-      [matched_condition, matched_context, event]
+      [matched_context, event]
     end
 
+    # @return [NilClass] when event is NOT given or executable context is NOT found
     # @param event [Plugin::Events::Event]
-    def execute(condition, context, event)
+    def execute(context, event)
       return unless 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
-
-      return if executor.nil?
-
-      # Check interval and execute
+      # Find executable context
       Config::Searcher.with_context(context) do
-        Config::Searcher.with_condition(condition) do
+        executor = @executors.find { |e| e.executable?(event) }
+        if executor
+          # Check interval and execute
           executor.enough_interval?(event) &&
             executor.update_interval(event) &&
             executor.execute(event)
@@ -191,5 +187,24 @@ module Fusuma
     def clear_expired_events
       @buffers.each(&:clear_expired)
     end
+
+    def set_trap
+      Signal.trap("INT") {
+        shutdown
+        puts exit
+      } # Trap ^C
+      Signal.trap("TERM") {
+        shutdown
+        puts exit
+      } # Trap `Kill `
+    end
+
+    private
+
+    def shutdown
+      [@inputs, @filters, @parsers, @buffers, @detectors, @executors].flatten.each do |plugin|
+        plugin.shutdown
+      end
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fusuma
 version: !ruby/object:Gem::Version
-  version: 2.5.1
+  version: 3.1.0
 platform: ruby
 authors:
 - iberianpig
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-11-12 00:00:00.000000000 Z
+date: 2023-09-03 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
@@ -59,6 +59,7 @@ files:
 - lib/fusuma/plugin/filters/libinput_device_filter.rb
 - lib/fusuma/plugin/inputs/input.rb
 - lib/fusuma/plugin/inputs/libinput_command_input.rb
+- lib/fusuma/plugin/inputs/libinput_command_input.yml
 - lib/fusuma/plugin/inputs/timer_input.rb
 - lib/fusuma/plugin/manager.rb
 - lib/fusuma/plugin/parsers/libinput_gesture_parser.rb
@@ -79,14 +80,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.5.1
+      version: '2.7'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3.1
+rubygems_version: 3.4.10
 signing_key: 
 specification_version: 4
 summary: Multitouch gestures with libinput driver, Linux