fusuma 1.10.2 → 2.0.1

data/lib/fusuma/plugin/events/records/gesture_record.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative './text_record.rb'
+require_relative './text_record'
 
 module Fusuma
   module Plugin
@@ -9,19 +9,22 @@ module Fusuma
         # Gesture Record
         class GestureRecord < Record
           # define gesture format
-          attr_reader :status, :gesture, :finger, :direction
+          attr_reader :status, :gesture, :finger, :delta
 
-          Delta = Struct.new(:move_x, :move_y, :zoom, :rotate)
+          Delta = Struct.new(:move_x, :move_y,
+                             :unaccelerated_x, :unaccelerated_y,
+                             :zoom, :rotate)
 
           # @param status [String]
           # @param gesture [String]
           # @param finger [String, Integer]
-          # @param direction [Delta, NilClass]
-          def initialize(status:, gesture:, finger:, direction:)
+          # @param delta [Delta, NilClass]
+          def initialize(status:, gesture:, finger:, delta:)
+            super()
             @status  = status
             @gesture = gesture
             @finger  = finger.to_i
-            @direction = direction
+            @delta = delta
           end
         end
       end

data/lib/fusuma/plugin/events/records/index_record.rb

@@ -8,36 +8,68 @@ module Fusuma
         # have index
         class IndexRecord < Record
           # define gesture format
-          attr_reader :index
-          attr_reader :position
+          attr_accessor :index
+          attr_reader :position, :trigger, :args
 
           # @param [Config::Index] index
           # @param [Symbol] position [:prefix, :body, :surfix]
-          def initialize(index:, position: :body)
+          # @param [Symbol] trigger [:oneshot, :repeat]
+          def initialize(index:, position: :body, trigger: :oneshot, args: {})
+            super()
             @index = index
             @position = position
+            @trigger = trigger
+            @args = args
           end
 
           def type
             :index
           end
 
+          # FIXME: move to Config::Index
           # @param records [Array<IndexRecord>]
-          # @return [IndexRecord]
-          def merge(records:)
+          # @return [IndexRecord] when merge is succeeded
+          # @return [NilClass] when merge is not succeeded
+          def merge(records:, index: @index)
+            # FIXME: cache
             raise "position is NOT body: #{self}" unless mergable?
 
-            @index = records.reduce(@index) do |merged_index, record|
-              case record.position
-              when :prefix
-                Config::Index.new([*record.index.keys, *merged_index.keys])
-              when :surfix
-                Config::Index.new([*merged_index.keys, *record.index.keys])
-              else
-                raise "invalid index position: #{record}"
+            if records.empty?
+              if Config.find_execute_key(index)
+                @index = index
+                return self
               end
+              return nil
+            end
+
+            record = records.shift
+            new_index = case record.position
+                        when :surfix
+                          Config::Index.new([*index.keys, *record.index.keys])
+                        else
+                          raise "invalid index position: #{record}"
+                        end
+
+            return unless exist_on_conf?(new_index)
+
+            merge(records: records, index: new_index)
+          end
+
+          # @param [Config::Searcher] searcher
+          def exist_on_conf?(index = @index)
+            Config.search(index)
+          end
+
+          # @return [Integer]
+          def trigger_priority
+            case @trigger
+            when :oneshot
+              10
+            when :repeat
+              100
+            else
+              1000
             end
-            self
           end
 
           def mergable?

data/lib/fusuma/plugin/events/records/record.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative '../../base.rb'
+require_relative '../../base'
 
 module Fusuma
   module Plugin

data/lib/fusuma/plugin/events/records/text_record.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative './record.rb'
+require_relative './record'
 
 module Fusuma
   module Plugin
@@ -10,6 +10,7 @@ module Fusuma
         class TextRecord < Record
           # @param text [String]
           def initialize(text)
+            super()
             @text = text
           end
 

data/lib/fusuma/plugin/executors/command_executor.rb

@@ -1,22 +1,30 @@
 # frozen_string_literal: true
 
-require_relative './executor.rb'
+require 'posix/spawn'
+require_relative './executor'
 
 module Fusuma
   module Plugin
     module Executors
       # Exector plugin
       class CommandExecutor < Executor
+        # Executor parameter on config.yml
+        # @return [Array<Symbol>]
+        def execute_keys
+          [:command]
+        end
+
         def execute(event)
           search_command(event).tap do |command|
             break unless command
 
-            MultiLogger.info(command: command)
-            pid = fork do
-              Process.daemon(true)
-              exec(command.to_s)
-            end
+            MultiLogger.info(command: command, args: event.record.args)
+
+            additional_env = event.record.args
+                                  .deep_transform_keys(&:to_s)
+                                  .deep_transform_values { |v| (v * args_accel(event)).to_s }
 
+            pid = POSIX::Spawn.spawn(additional_env, command.to_s)
             Process.detach(pid)
           end
         end
@@ -33,6 +41,13 @@ module Fusuma
           command_index = Config::Index.new([*event.record.index.keys, :command])
           Config.search(command_index)
         end
+
+        # @param event [Event]
+        # @return [Float]
+        def args_accel(event)
+          accel_index = Config::Index.new([*event.record.index.keys, :accel])
+          (Config.search(accel_index) || 1).to_f
+        end
       end
     end
   end

data/lib/fusuma/plugin/executors/executor.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative '../base.rb'
+require_relative '../base'
 
 module Fusuma
   module Plugin
@@ -8,14 +8,56 @@ module Fusuma
     module Executors
       # Inherite this base
       class Executor < Base
+        BASE_ONESHOT_INTERVAL = 0.3
+        BASE_REPEAT_INTERVAL = 0.1
+
+        # Executor parameter on config.yml
+        # @return [Array<Symbol>]
+        def execute_keys
+          # [name.split('Executors::').last.underscore.gsub('_executor', '').to_sym]
+          raise NotImplementedError, "override #{name}##{__method__}"
+        end
+
         # check executable
-        # @param _event [Event]
+        # @param _event [Events::Event]
         # @return [TrueClass, FalseClass]
         def executable?(_event)
           raise NotImplementedError, "override #{self.class.name}##{__method__}"
         end
 
-        # execute somthing
+        # @param event [Events::Event]
+        # @param time [Time]
+        # @return [TrueClass, FalseClass]
+        def enough_interval?(event)
+          # NOTE: Cache at the index that is actually used, reflecting Fallback and Skip.
+          #       Otherwise, a wrong index will cause invalid intervals.
+          return true if event.record.index.with_context.keys.any? { |key| key.symbol == :end }
+
+          return false if @wait_until && event.time < @wait_until
+
+          true
+        end
+
+        def update_interval(event)
+          @wait_until = event.time + interval(event).to_f
+        end
+
+        def interval(event)
+          @interval_time ||= {}
+          index = event.record.index
+          @interval_time[index.cache_key] ||= begin
+            config_value =
+              Config.search(Config::Index.new([*index.keys, 'interval'])) ||
+              Config.search(Config::Index.new(['interval', Detectors::Detector.type(event.tag)]))
+            if event.record.trigger == :oneshot
+              (config_value || 1) * BASE_ONESHOT_INTERVAL
+            else
+              (config_value || 1) * BASE_REPEAT_INTERVAL
+            end
+          end
+        end
+
+        # execute something
         # @param _event [Event]
         # @return [nil]
         def execute(_event)

data/lib/fusuma/plugin/filters/filter.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative '../base.rb'
+require_relative '../base'
 
 module Fusuma
   module Plugin

data/lib/fusuma/plugin/filters/libinput_device_filter.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require_relative './filter.rb'
-require_relative '../../device.rb'
+require_relative './filter'
+require_relative '../../device'
 
 module Fusuma
   module Plugin
@@ -25,15 +25,14 @@ module Fusuma
             keep_device.reset
             return false
           end
-
-          keep_device.all.map(&:id).any? { |device_id| record.to_s =~ /^\s?#{device_id}\s/ }
+          keep_device.all.map(&:id).any? { |device_id| record.to_s =~ /^[\s-]?#{device_id}\s/ }
         end
 
         def keep_device
           @keep_device ||= begin
-                             from_config = Array(config_params(:keep_device_names))
-                             KeepDevice.new(name_patterns: from_config)
-                           end
+            from_config = Array(config_params(:keep_device_names))
+            KeepDevice.new(name_patterns: from_config)
+          end
         end
 
         def config_param_sample

data/lib/fusuma/plugin/filters/libinput_timeout_filter.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require_relative './filter.rb'
-require_relative '../../libinput_command.rb'
+require_relative './filter'
+require_relative '../../libinput_command'
 
 module Fusuma
   module Plugin

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

@@ -1,22 +1,57 @@
 # frozen_string_literal: true
 
-require_relative '../base.rb'
-require_relative '../events/event.rb'
+require_relative '../base'
+require_relative '../events/event'
 
 module Fusuma
   module Plugin
-    # input class
     module Inputs
       # Inherite this base
+      # @abstract Subclass and override {#io} to implement
       class Input < Base
-        def run
+        # Wait multiple inputs until it becomes readable
+        # and read lines with nonblock
+        # @param inputs [Array<Input>]
+        # @return [Event]
+        def self.select(inputs)
+          ios = IO.select(inputs.map(&:io))
+          io = ios&.first&.first
+
+          input = inputs.find { |i| i.io == io }
+
+          begin
+            line = io.readline_nonblock("\n").chomp
+          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
+          rescue StandardError => e
+            warn "#{input.class.name}: #{e}"
+            exit 1
+          end
+
+          input.create_event(record: line)
+        end
+
+        # @return [Integer]
+        def pid
           raise NotImplementedError, "override #{self.class.name}##{__method__}"
         end
 
-        def event(record: 'dummy input')
-          Events::Event.new(tag: tag, record: record).tap do |e|
-            MultiLogger.debug(input_event: e)
-          end
+        # @return [IO]
+        def io
+          raise NotImplementedError, "override #{self.class.name}##{__method__}"
+        end
+
+        # @return [Event]
+        def create_event(record: 'dummy input')
+          e = Events::Event.new(tag: tag, record: record)
+          MultiLogger.debug(input_event: e)
+          e
         end
 
         def tag
@@ -26,3 +61,24 @@ module Fusuma
     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.rb

@@ -1,37 +1,47 @@
 # frozen_string_literal: true
 
-require_relative '../../libinput_command.rb'
-require_relative './input.rb'
+require_relative '../../libinput_command'
+require_relative './input'
 
 module Fusuma
   module Plugin
     module Inputs
       # libinput commands wrapper
       class LibinputCommandInput < Input
+        attr_reader :pid
+
         def config_param_types
           {
-            'device': [String],
+            device: [String],
             'enable-dwt': [TrueClass, FalseClass],
             'enable-tap': [TrueClass, FalseClass],
             'show-keycodes': [TrueClass, FalseClass],
-            'verbose': [TrueClass, FalseClass],
+            verbose: [TrueClass, FalseClass],
             'libinput-debug-events': [String],
             'libinput-list-devices': [String]
           }
         end
 
-        def run
-          LibinputCommand.new(
+        # @return [IO]
+        def io
+          @io ||= begin
+            @pid, io = command.debug_events
+            io
+          end
+        end
+
+        # @return [LibinputCommand]
+        def command
+          @command ||= LibinputCommand.new(
             libinput_options: libinput_options,
             commands: {
               debug_events_command: debug_events_command,
               list_devices_command: list_devices_command
             }
-          ).debug_events do |line|
-            yield event(record: line)
-          end
+          )
         end
 
+        # @return [Array]
         def libinput_options
           device = ("--device='#{config_params(:device)}'" if config_params(:device))
           enable_tap = '--enable-tap' if config_params(:'enable-tap')