fusuma 2.5.1 → 3.1.0

data/lib/fusuma/custom_process.rb

@@ -1,21 +1,53 @@
 # frozen_string_literal: true
 
-require "fusuma/string_support"
+require_relative "./string_support"
 
 module Fusuma
   # Rename process
   module CustomProcess
     attr_writer :proctitle
 
+    def child_pids
+      @child_pids ||= []
+    end
+
     def fork
-      Process.fork do
+      pid = Process.fork do
         Process.setproctitle(proctitle)
+        set_trap # for child process
         yield
       end
+      child_pids << pid
+      pid
+    end
+
+    def shutdown
+      child_pids.each do |pid|
+        Process.kill("TERM", pid)
+      rescue Errno::ESRCH
+        # ignore
+      end
+
+      child_pids.each do |pid|
+        Process.wait(pid)
+      rescue Errno::ECHILD
+        # ignore
+      end
     end
 
     def proctitle
       @proctitle ||= self.class.name.underscore
     end
+
+    def set_trap
+      Signal.trap("INT") {
+        shutdown
+        exit
+      } # Trap ^C
+      Signal.trap("TERM") {
+        shutdown
+        exit
+      } # Trap `Kill `
+    end
   end
 end

data/lib/fusuma/device.rb

@@ -66,6 +66,7 @@ module Fusuma
         line_parser = LineParser.new
 
         libinput_command = Plugin::Inputs::LibinputCommandInput.new.command
+        # note: this libinput command takes a nontrivial amout of time (~200ms)
         libinput_command.list_devices do |line|
           line_parser.push(line)
         end

data/lib/fusuma/environment.rb

@@ -39,6 +39,12 @@ module Fusuma
           puts device.name
         end
       end
+
+      def print_config
+        Config.instance.keymap.each do |conf|
+          puts conf.deep_stringify_keys.to_yaml
+        end
+      end
     end
   end
 end

data/lib/fusuma/hash_support.rb

@@ -2,6 +2,28 @@
 
 # Patch to hash
 class Hash
+  # activesupport-5.2.0/lib/active_support/core_ext/hash/deep_merge.rb
+  def deep_merge(other_hash, &block)
+    dup.deep_merge!(other_hash, &block)
+  end
+
+  # Same as +deep_merge+, but modifies +self+.
+  def deep_merge!(other_hash, &block)
+    merge!(other_hash) do |key, this_val, other_val|
+      if this_val.is_a?(Hash) && other_val.is_a?(Hash)
+        this_val.deep_merge(other_val, &block)
+      elsif block
+        block.call(key, this_val, other_val)
+      else
+        other_val
+      end
+    end
+  end
+
+  def deep_stringify_keys
+    deep_transform_keys(&:to_s)
+  end
+
   # activesupport-4.1.1/lib/active_support/core_ext/hash/keys.rb
   def deep_symbolize_keys
     deep_transform_keys do |key|

data/lib/fusuma/multi_logger.rb

@@ -32,6 +32,8 @@ module Fusuma
     def debug(msg)
       return unless debug_mode?
 
+      return if ignore_pattern?(msg)
+
       super(msg)
     end
 
@@ -47,6 +49,20 @@ module Fusuma
       debug_mode
     end
 
+    def ignore_pattern?(msg)
+      # TODO: configurable from config.yml
+      pattern = /timer_input/
+      case msg
+      when Hash
+        e = msg.values.find { |v| v.is_a? Fusuma::Plugin::Events::Event }
+        return unless e
+
+        e.tag.match?(pattern)
+      else
+        false
+      end
+    end
+
     class << self
       def info(msg)
         instance.info(msg)

data/lib/fusuma/plugin/base.rb

@@ -8,7 +8,6 @@ module Fusuma
   module Plugin
     # Create a Plugin Class with extending this class
     class Base
-      include CustomProcess
       # when inherited from subclass
       def self.inherited(subclass)
         super
@@ -22,20 +21,30 @@ module Fusuma
         Manager.plugins[name]
       end
 
+      # @abstract override `#shutdown` to implement
+      def shutdown
+      end
+
       # config parameter name and Type of the value of parameter
       # @return [Hash]
       def config_param_types
         raise NotImplementedError, "override #{self.class.name}##{__method__}"
       end
 
+      # @param key [Symbol]
+      # @param base [Config::Index]
       # @return [Object]
-      def config_params(key = nil, base: config_index)
-        params = Config.search(base) || {}
+      def config_params(key = nil)
+        @config_params ||= {}
+        if @config_params["#{config_index.cache_key},#{key}"]
+          return @config_params["#{config_index.cache_key},#{key}"]
+        end
+
+        params = Config.instance.fetch_config_params(key, config_index)
 
         return params unless key
 
-        @config_params ||= {}
-        @config_params["#{base.cache_key},#{key}"] ||=
+        @config_params["#{config_index.cache_key},#{key}"] =
           params.fetch(key, nil).tap do |val|
             next if val.nil?
 
@@ -45,14 +54,14 @@ module Fusuma
             next if param_types.any? { |klass| val.is_a?(klass) }
 
             MultiLogger.error("Please fix config.yml.")
-            MultiLogger.error(":#{base.keys.map(&:symbol)
+            MultiLogger.error(":#{config_index.keys.map(&:symbol)
             .join(" => :")} => :#{key} should be #{param_types.join(" OR ")}.")
             exit 1
           end
       end
 
       def config_index
-        Config::Index.new(self.class.name.gsub("Fusuma::", "").underscore.split("/"))
+        @config_index ||= Config::Index.new(self.class.name.gsub("Fusuma::", "").underscore.split("/"))
       end
     end
   end

data/lib/fusuma/plugin/buffers/gesture_buffer.rb

@@ -7,9 +7,24 @@ module Fusuma
     module Buffers
       # manage events and generate command
       class GestureBuffer < Buffer
+        CacheEntry = Struct.new(:checked, :value)
         DEFAULT_SOURCE = "libinput_gesture_parser"
         DEFAULT_SECONDS_TO_KEEP = 100
 
+        def initialize(*args)
+          super(*args)
+          @cache = {}
+          @cache_select_by = {}
+          @cache_sum10 = {}
+        end
+
+        def clear
+          super.clear
+          @cache = {}
+          @cache_select_by = {}
+          @cache_sum10 = {}
+        end
+
         def config_param_types
           {
             source: [String],
@@ -40,6 +55,9 @@ module Fusuma
             MultiLogger.debug("#{self.class.name}##{__method__}")
 
             @events.delete(e)
+            @cache = {}
+            @cache_select_by = {}
+            @cache_sum10 = {}
           end
         end
 
@@ -59,11 +77,35 @@ module Fusuma
         def sum_attrs(attr)
           updating_events.map do |gesture_event|
             gesture_event.record.delta[attr].to_f
-          end.inject(:+)
+          end.reduce(:+)
+        end
+
+        # @param attr [Symbol]
+        # @return [Float]
+        def sum_last10_attrs(attr) # sums last 10 values of attr (or all if length < 10)
+          cache_entry = (@cache_sum10[attr] ||= CacheEntry.new(0, 0))
+          upd_ev = updating_events
+          if upd_ev.length > cache_entry.checked + 1
+            cache_entry.value = upd_ev.last(10).map do |gesture_event|
+              gesture_event.record.delta[attr].to_f
+            end.reduce(:+)
+          elsif upd_ev.length > cache_entry.checked
+            cache_entry.value = cache_entry.value + upd_ev[-1].record.delta[attr].to_f - \
+              ((upd_ev.length > 10) ? upd_ev[-11].record.delta[attr].to_f : 0)
+          else
+            return cache_entry.value
+          end
+          cache_entry.checked = upd_ev.length
+          cache_entry.value
         end
 
         def updating_events
-          @events.select { |e| e.record.status == "update" }
+          cache_entry = (@cache[:updating_events] ||= CacheEntry.new(0, []))
+          cache_entry.checked.upto(@events.length - 1).each do |i|
+            (cache_entry.value << @events[i]) if @events[i].record.status == "update"
+          end
+          cache_entry.checked = @events.length
+          cache_entry.value
         end
 
         # @param attr [Symbol]
@@ -96,14 +138,28 @@ module Fusuma
           self.class.new events
         end
 
+        def select_by_type(type)
+          cache_entry = (@cache_select_by[type] ||= CacheEntry.new(0, self.class.new([])))
+          cache_entry.checked.upto(@events.length - 1).each do |i|
+            (cache_entry.value.events << @events[i]) if @events[i].record.gesture == type
+          end
+          cache_entry.checked = @events.length
+          cache_entry.value
+        end
+
         def select_from_last_begin
           return self if empty?
+          cache_entry = (@cache[:last_begin] ||= CacheEntry.new(0, nil))
+
+          cache_entry.value = (@events.length - 1).downto(cache_entry.checked).find do |i|
+            @events[i].record.status == "begin"
+          end || cache_entry.value
+          cache_entry.checked = @events.length
 
-          index_from_last = @events.reverse.find_index { |e| e.record.status == "begin" }
-          return GestureBuffer.new([]) if index_from_last.nil?
+          return self if cache_entry.value == 0
+          return GestureBuffer.new([]) if cache_entry.value.nil?
 
-          index_last_begin = events.length - index_from_last - 1
-          GestureBuffer.new(@events[index_last_begin..-1])
+          GestureBuffer.new(@events[cache_entry.value..-1])
         end
       end
     end

data/lib/fusuma/plugin/detectors/detector.rb

@@ -8,9 +8,18 @@ module Fusuma
     module Detectors
       # Inherite this base
       class Detector < Base
+        def initialize(*args)
+          super(*args)
+          @tag = self.class.tag
+          @type = self.class.type
+        end
+
+        attr_reader :tag
+        attr_reader :type
+
         # @return [Array<String>]
         def sources
-          @source ||= self.class.const_get(:SOURCES)
+          @sources ||= self.class.const_get(:SOURCES)
         end
 
         # Always watch buffers and detect them or not
@@ -43,14 +52,6 @@ module Fusuma
           @last_time.nil?
         end
 
-        def tag
-          self.class.tag
-        end
-
-        def type
-          self.class.type
-        end
-
         class << self
           def tag
             name.split("Detectors::").last.underscore

data/lib/fusuma/plugin/detectors/hold_detector.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "./detector"
+require_relative "../inputs/timer_input"
 
 module Fusuma
   module Plugin
@@ -13,6 +14,11 @@ module Fusuma
 
         BASE_THERESHOLD = 0.7
 
+        def initialize(*args)
+          super(*args)
+          @timer = Inputs::TimerInput.instance
+        end
+
         # @param buffers [Array<Buffers::Buffer>]
         # @return [Events::Event] if event is detected
         # @return [Array<Events::Event>] if hold end event is detected
@@ -21,16 +27,15 @@ module Fusuma
           hold_buffer = find_hold_buffer(buffers)
           return if hold_buffer.empty?
 
-          hold_events = hold_buffer.events
+          last_hold = hold_buffer.events.last
 
           timer_buffer = buffers.find { |b| b.type == "timer" }
-          timer_events = timer_buffer.events
+          last_timer = timer_buffer.events.last
 
           finger = hold_buffer.finger
-          holding_time = calc_holding_time(hold_events: hold_events, timer_events: timer_events)
+          holding_time = calc_holding_time(hold_events: hold_buffer.events, last_timer: last_timer)
 
-          @timeout ||= nil
-          status = case hold_events.last.record.status
+          status = case last_hold.record.status
           when "begin"
             if holding_time.zero?
               "begin"
@@ -42,16 +47,19 @@ module Fusuma
           when "end"
             "end"
           else
-            last_record = hold_events.last.record.status
+            last_record = last_hold.record.status
             raise "Unexpected Status:#{last_record.status} in #{last_record}"
           end
 
           repeat_index = create_repeat_index(finger: finger, status: status)
           oneshot_index = create_oneshot_index(finger: finger)
 
-          @timeout = nil if status == "begin"
-
-          if status == "timer"
+          if status == "begin"
+            @timeout = nil
+            if threshold(index: oneshot_index) < @timer.interval
+              @timer.wake_early(Time.now + threshold(index: oneshot_index))
+            end
+          elsif status == "timer"
             return if @timeout
 
             return unless enough?(index: oneshot_index, holding_time: holding_time)
@@ -97,12 +105,12 @@ module Fusuma
         def find_hold_buffer(buffers)
           buffers.find { |b| b.type == BUFFER_TYPE }
             .select_from_last_begin
-            .select_by_events { |e| e.record.gesture == GESTURE_RECORD_TYPE }
+            .select_by_type(GESTURE_RECORD_TYPE)
         end
 
-        def calc_holding_time(hold_events:, timer_events:)
-          last_time = if !timer_events.empty? && (hold_events.last.time < timer_events.last.time)
-            timer_events.last.time
+        def calc_holding_time(hold_events:, last_timer:)
+          last_time = if last_timer && (hold_events.last.time < last_timer.time)
+            last_timer.time
           else
             hold_events.last.time
           end
@@ -110,7 +118,13 @@ module Fusuma
         end
 
         def enough?(index:, holding_time:)
-          holding_time > threshold(index: index)
+          diff = threshold(index: index) - holding_time
+          if diff < 0
+            true
+          elsif diff < @timer.interval
+            @timer.wake_early(Time.now + diff)
+            false
+          end
         end
 
         def threshold(index:)

data/lib/fusuma/plugin/detectors/pinch_detector.rb

@@ -19,7 +19,7 @@ module Fusuma
         def detect(buffers)
           gesture_buffer = buffers.find { |b| b.type == BUFFER_TYPE }
             .select_from_last_begin
-            .select_by_events { |e| e.record.gesture == GESTURE_RECORD_TYPE }
+            .select_by_type(GESTURE_RECORD_TYPE)
 
           updating_events = gesture_buffer.updating_events
           return if updating_events.empty?
@@ -100,10 +100,10 @@ module Fusuma
         def create_repeat_index(gesture:, finger:, direction:, status:)
           Config::Index.new(
             [
-              Config::Index::Key.new(gesture),
-              Config::Index::Key.new(finger.to_i),
-              Config::Index::Key.new(direction, skippable: true),
-              Config::Index::Key.new(status)
+              Config::Index::Key.new(gesture), # 'pinch'
+              Config::Index::Key.new(finger.to_i), # 2, 3, 4
+              Config::Index::Key.new(direction, skippable: true), # 'in', 'out'
+              Config::Index::Key.new(status) # 'begin', 'update', 'end'
             ]
           )
         end
@@ -115,9 +115,9 @@ module Fusuma
         def create_oneshot_index(gesture:, finger:, direction:)
           Config::Index.new(
             [
-              Config::Index::Key.new(gesture),
-              Config::Index::Key.new(finger.to_i, skippable: true),
-              Config::Index::Key.new(direction)
+              Config::Index::Key.new(gesture), # 'pinch'
+              Config::Index::Key.new(finger.to_i, skippable: true), # 2, 3, 4
+              Config::Index::Key.new(direction) # 'in', 'out'
             ]
           )
         end
@@ -161,9 +161,9 @@ module Fusuma
 
           def calc
             if @target > @base
-              IN
-            else
               OUT
+            else
+              IN
             end
           end
         end

data/lib/fusuma/plugin/detectors/rotate_detector.rb

@@ -19,21 +19,14 @@ module Fusuma
         def detect(buffers)
           gesture_buffer = buffers.find { |b| b.type == BUFFER_TYPE }
             .select_from_last_begin
-            .select_by_events { |e| e.record.gesture == GESTURE_RECORD_TYPE }
+            .select_by_type(GESTURE_RECORD_TYPE)
 
           updating_events = gesture_buffer.updating_events
           return if updating_events.empty?
 
-          oneshot_angle = if updating_events.size >= 10
-            updating_time = 100 * (updating_events[-1].time - updating_events[-10].time)
-            last_10 = gesture_buffer.class.new(updating_events[-10..-1])
-            last_10.sum_attrs(:rotate) / updating_time
-          else
-            updating_time = 100 * (updating_events.last.time - updating_events.first.time)
-            gesture_buffer.sum_attrs(:rotate) / updating_time
-          end
-
-          return if updating_events.empty?
+          updating_time = 100 * (updating_events[-1].time -
+                                 (updating_events[-10] || updating_events.first).time)
+          oneshot_angle = gesture_buffer.sum_last10_attrs(:rotate) / updating_time
 
           finger = gesture_buffer.finger
 

data/lib/fusuma/plugin/detectors/swipe_detector.rb

@@ -19,22 +19,15 @@ module Fusuma
         def detect(buffers)
           gesture_buffer = buffers.find { |b| b.type == BUFFER_TYPE }
             .select_from_last_begin
-            .select_by_events { |e| e.record.gesture == GESTURE_RECORD_TYPE }
+            .select_by_type(GESTURE_RECORD_TYPE)
 
           updating_events = gesture_buffer.updating_events
           return if updating_events.empty?
 
-          oneshot_move_x, oneshot_move_y = if updating_events.size >= 10
-            updating_time = 100 * (updating_events[-1].time - updating_events[-10].time)
-            last_10 = gesture_buffer.class.new(updating_events[-10..-1])
-            [last_10.sum_attrs(:move_x) / updating_time,
-              last_10.sum_attrs(:move_y) / updating_time]
-          else
-            updating_time = 100 * (updating_events.last.time - updating_events.first.time)
-            [gesture_buffer.sum_attrs(:move_x) / updating_time,
-              gesture_buffer.sum_attrs(:move_y) / updating_time]
-          end
-          (gesture_buffer.sum_attrs(:move_x) / updating_time)
+          updating_time = 100 * (updating_events.last.time -
+                                 (updating_events[-10] || updating_events.first).time)
+          oneshot_move_x = gesture_buffer.sum_last10_attrs(:move_x) / updating_time
+          oneshot_move_y = gesture_buffer.sum_last10_attrs(:move_y) / updating_time
 
           finger = gesture_buffer.finger
           status = case gesture_buffer.events.last.record.status
@@ -67,8 +60,7 @@ module Fusuma
 
             oneshot_direction = Direction.new(move_x: oneshot_move_x, move_y: oneshot_move_y).to_s
             oneshot_quantity = Quantity.new(move_x: oneshot_move_x, move_y: oneshot_move_y).to_f
-            oneshot_index = create_oneshot_index(gesture: type, finger: finger,
-              direction: oneshot_direction)
+            oneshot_index = create_oneshot_index(gesture: type, finger: finger, direction: oneshot_direction)
             if enough_oneshot_threshold?(index: oneshot_index, quantity: oneshot_quantity)
               return [
                 create_event(record: Events::Records::IndexRecord.new(
@@ -109,7 +101,7 @@ module Fusuma
           Config::Index.new(
             [
               Config::Index::Key.new(gesture),
-              Config::Index::Key.new(finger.to_i, skippable: true),
+              Config::Index::Key.new(finger.to_i),
               Config::Index::Key.new(direction)
             ]
           )
@@ -175,7 +167,7 @@ module Fusuma
           end
 
           def calc
-            @x > @y ? @x.abs : @y.abs
+            (@x > @y) ? @x.abs : @y.abs
           end
         end
       end

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

@@ -11,9 +11,12 @@ module Fusuma
           # define gesture format
           attr_reader :status, :gesture, :finger, :delta
 
-          Delta = Struct.new(:move_x, :move_y,
+          Delta = Struct.new(
+            :move_x, :move_y,
             :unaccelerated_x, :unaccelerated_y,
-            :zoom, :rotate)
+            :zoom,
+            :rotate
+          )
 
           # @param status [String]
           # @param gesture [String]

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

@@ -35,7 +35,7 @@ module Fusuma
             raise "position is NOT body: #{self}" unless mergable?
 
             if records.empty?
-              if Config.find_execute_key(index)
+              if Config.instance.find_execute_key(index)
                 @index = index
                 return self
               end

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

@@ -39,14 +39,14 @@ module Fusuma
         # @return [String]
         def search_command(event)
           command_index = Config::Index.new([*event.record.index.keys, :command])
-          Config.search(command_index)
+          Config.instance.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
+          (Config.instance.search(accel_index) || 1).to_f
         end
       end
     end

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

@@ -26,12 +26,9 @@ module Fusuma
         end
 
         # @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 true if event.record.index.keys.any? { |key| key.symbol == :end }
 
           return false if @wait_until && event.time < @wait_until
 

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

@@ -25,7 +25,8 @@ module Fusuma
             keep_device.reset
             return false
           end
-          keep_device.all.map(&:id).any? { |device_id| record.to_s =~ /^[\s-]?#{device_id}\s/ }
+          device_id = record.to_s.match(/\S*/, 1).to_s
+          keep_device.all.map(&:id).include?(device_id)
         end
 
         def keep_device