fusuma 3.9.0 → 3.10.0

data/lib/fusuma/multi_logger.rb

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
 
+require "logger"
+require "singleton"
+
 # module as namespace
 module Fusuma
-  require "logger"
-  require "singleton"
   # logger separate between stdout and strerr
   class MultiLogger < Logger
     include Singleton
@@ -14,23 +15,28 @@ module Fusuma
     class << self
       attr_writer :filepath
 
+      #: (untyped) -> void
       def info(msg)
         instance.info(msg)
       end
 
+      #: (untyped) -> void
       def debug(msg)
         instance.debug(msg)
       end
 
+      #: (untyped) -> void
       def warn(msg)
         instance.warn(msg)
       end
 
+      #: (untyped) -> void
       def error(msg)
         instance.error(msg)
       end
     end
 
+    #: () -> void
     def initialize
       filepath = self.class.instance_variable_get(:@filepath)
       if filepath
@@ -45,28 +51,33 @@ module Fusuma
       @debug_mode = false
     end
 
+    #: (untyped) -> void
     def debug(msg)
       return unless debug_mode?
 
       return if ignore_pattern?(msg)
 
-      super(msg)
+      super
     end
 
+    #: (untyped) -> void
     def warn(msg)
       err_logger.warn(msg)
     end
 
+    #: (untyped) -> void
     def error(msg)
       err_logger.error(msg)
     end
 
+    #: () -> bool
     def debug_mode?
       debug_mode
     end
 
     private
 
+    #: (String) -> bool
     def ignore_pattern?(msg)
       # TODO: configurable from config.yml
       # pattern = /timer_input|remap_touchpad_input|thumbsense context|libinput_command_input/
@@ -74,7 +85,7 @@ module Fusuma
       case msg
       when Hash
         e = msg.values.find { |v| v.is_a? Fusuma::Plugin::Events::Event }
-        return unless e
+        return false unless e
 
         e.tag.match?(pattern)
       when String

data/lib/fusuma/plugin/base.rb

@@ -11,7 +11,13 @@ module Fusuma
       # when inherited from subclass
       def self.inherited(subclass)
         super
-        subclass_path = caller_locations(1..1).first.path
+
+        locations = Kernel.caller_locations(1..1)
+        if locations.nil? || locations.empty?
+          raise "Plugin class #{subclass.name} must be defined in a file."
+        end
+
+        subclass_path = locations.first.path
         Manager.add(plugin_class: subclass, plugin_path: subclass_path)
       end
 
@@ -22,11 +28,13 @@ module Fusuma
       end
 
       # @abstract override `#shutdown` to implement
+      #: () -> nil
       def shutdown
       end
 
       # config parameter name and Type of the value of parameter
       # @return [Hash]
+      #: () -> Hash[Symbol, Array[Class] | Class]
       def config_param_types
         raise NotImplementedError, "override #{self.class.name}##{__method__}"
       end
@@ -34,6 +42,7 @@ module Fusuma
       # @param key [Symbol]
       # @param base [Config::Index]
       # @return [Object]
+      #: (?Symbol?) -> (String | Hash[untyped, untyped] | Float | bool)?
       def config_params(key = nil)
         @config_params ||= {}
         if @config_params["#{config_index.cache_key},#{key}"]
@@ -59,6 +68,7 @@ module Fusuma
           end
       end
 
+      #: () -> Fusuma::Config::Index
       def config_index
         @config_index ||= Config::Index.new(self.class.name.gsub("Fusuma::", "").underscore.split("/"))
       end

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

@@ -7,6 +7,7 @@ module Fusuma
     module Buffers
       # buffer events and output
       class Buffer < Base
+        #: (*nil | Array[untyped]) -> void
         def initialize(*args)
           super()
           @events = Array.new(*args)
@@ -15,11 +16,13 @@ module Fusuma
         attr_reader :events
 
         # @return [String]
+        #: () -> String
         def type
           @type ||= self.class.name.underscore.split("/").last.gsub("_buffer", "")
         end
 
         # @param event [Event]
+        #: (Fusuma::Plugin::Events::Event) -> Array[untyped]?
         def buffer(event)
           return if event&.tag != source
 
@@ -32,17 +35,20 @@ module Fusuma
         end
 
         # @return [TrueClass, FalseClass]
+        #: () -> bool
         def empty?
           @events.empty?
         end
 
         # clear buffer
+        #: () -> void
         def clear
           @events.clear
         end
 
         # Set source for tag from config.yml.
         # DEFAULT_SOURCE is defined in each plugins.
+        #: () -> String
         def source
           @source ||= config_params(:source) || self.class.const_get(:DEFAULT_SOURCE)
         end

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

@@ -11,6 +11,7 @@ module Fusuma
         DEFAULT_SOURCE = "libinput_gesture_parser"
         DEFAULT_SECONDS_TO_KEEP = 100
 
+        #: (*nil | Array[untyped]) -> void
         def initialize(*args)
           super
           @cache = {}
@@ -18,6 +19,7 @@ module Fusuma
           @cache_sum10 = {}
         end
 
+        #: () -> Hash[untyped, untyped]
         def clear
           super.clear
           @cache = {}
@@ -25,6 +27,7 @@ module Fusuma
           @cache_sum10 = {}
         end
 
+        #: () -> Hash[Symbol, Array[Class] | Class]
         def config_param_types
           {
             source: [String],
@@ -34,6 +37,7 @@ module Fusuma
 
         # @param event [Event]
         # @return [Buffer, FalseClass]
+        #: (Fusuma::Plugin::Events::Event) -> Fusuma::Plugin::Buffers::GestureBuffer?
         def buffer(event)
           # TODO: buffering events into buffer plugins
           # - gesture event buffer
@@ -45,10 +49,11 @@ module Fusuma
           self
         end
 
+        #: (?current_time: Time) -> void
         def clear_expired(current_time: Time.now)
           clear if ended?
 
-          @seconds_to_keep ||= (config_params(:seconds_to_keep) || DEFAULT_SECONDS_TO_KEEP)
+          @seconds_to_keep ||= config_params(:seconds_to_keep) || DEFAULT_SECONDS_TO_KEEP
           @events.each do |e|
             break if current_time - e.time < @seconds_to_keep
 
@@ -61,6 +66,7 @@ module Fusuma
           end
         end
 
+        #: () -> bool
         def ended?
           return false if empty?
 
@@ -74,6 +80,7 @@ module Fusuma
 
         # @param attr [Symbol]
         # @return [Float]
+        #: (Symbol) -> Float
         def sum_attrs(attr)
           updating_events.map do |gesture_event|
             gesture_event.record.delta[attr].to_f
@@ -82,6 +89,7 @@ module Fusuma
 
         # @param attr [Symbol]
         # @return [Float]
+        #: (Symbol) -> 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
@@ -90,7 +98,7 @@ module Fusuma
               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 - \
+            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
@@ -99,6 +107,7 @@ module Fusuma
           cache_entry.value
         end
 
+        #: () -> Array[untyped]
         def updating_events
           cache_entry = (@cache[:updating_events] ||= CacheEntry.new(0, []))
           cache_entry.checked.upto(@events.length - 1).each do |i|
@@ -110,11 +119,13 @@ module Fusuma
 
         # @param attr [Symbol]
         # @return [Float]
+        #: (Symbol) -> Float
         def avg_attrs(attr)
           sum_attrs(attr).to_f / updating_events.length
         end
 
         # return [Integer]
+        #: () -> Integer
         def finger
           @events.last.record.finger.to_i
         end
@@ -127,13 +138,7 @@ module Fusuma
           @events.last.record.gesture
         end
 
-        def select_by_events(&block)
-          return enum_for(:select_by_events) unless block
-
-          events = @events.select(&block)
-          self.class.new events
-        end
-
+        #: (String) -> Fusuma::Plugin::Buffers::GestureBuffer
         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|
@@ -143,6 +148,7 @@ module Fusuma
           cache_entry.value
         end
 
+        #: () -> Fusuma::Plugin::Buffers::GestureBuffer
         def select_from_last_begin
           return self if empty?
           cache_entry = (@cache[:last_begin] ||= CacheEntry.new(0, nil))

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

@@ -19,6 +19,7 @@ module Fusuma
 
         # @param event [Event]
         # @return [Buffer, NilClass]
+        #: (Fusuma::Plugin::Events::Event) -> Fusuma::Plugin::Buffers::TimerBuffer?
         def buffer(event)
           return if event&.tag != source
 
@@ -27,7 +28,7 @@ module Fusuma
         end
 
         def clear_expired(current_time: Time.now)
-          @seconds_to_keep ||= (config_params(:seconds_to_keep) || DEFAULT_SECONDS_TO_KEEP)
+          @seconds_to_keep ||= config_params(:seconds_to_keep) || DEFAULT_SECONDS_TO_KEEP
           @events.each do |e|
             break if current_time - e.time < @seconds_to_keep
 

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

@@ -8,22 +8,29 @@ module Fusuma
     module Detectors
       # Inherite this base
       class Detector < Base
+        def self.type(tag_name)
+          tag_name.gsub("_detector", "")
+        end
+
+        #: (*nil) -> void
         def initialize(*args)
           super
-          @tag = self.class.tag
-          @type = self.class.type
+          @tag = self.class.name.split("Detectors::").last.underscore
+          @type = self.class.type(@tag)
         end
 
-        attr_reader :tag
-        attr_reader :type
+        attr_reader :tag #: String
+        attr_reader :type #: String
 
         # @return [Array<String>]
+        #: () -> Array[String]
         def sources
           @sources ||= self.class.const_get(:SOURCES)
         end
 
         # Always watch buffers and detect them or not
         # @return [TrueClass,FalseClass]
+        #: () -> bool
         def watch?
           false
         end
@@ -39,28 +46,21 @@ module Fusuma
 
         # @param record [Events::Records::Record]
         # @return [Events::Event]
+        #: (record: Fusuma::Plugin::Events::Records::IndexRecord) -> Fusuma::Plugin::Events::Event
         def create_event(record:)
           @last_time = Time.now
-          Events::Event.new(time: @last_time, tag: tag, record: record)
+          Events::Event.new(time: @last_time, tag: @tag, record: record)
         end
 
+        #: () -> Time
         def last_time
           @last_time ||= Time.now
         end
 
+        #: () -> bool
         def first_time?
           @last_time.nil?
         end
-
-        class << self
-          def tag
-            name.split("Detectors::").last.underscore
-          end
-
-          def type(tag_name = tag)
-            tag_name.gsub("_detector", "")
-          end
-        end
       end
     end
   end

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

@@ -14,6 +14,7 @@ module Fusuma
 
         BASE_THRESHOLD = 0.7
 
+        #: (*nil) -> void
         def initialize(*args)
           super
           @timer = Inputs::TimerInput.instance
@@ -23,6 +24,7 @@ module Fusuma
         # @return [Events::Event] if event is detected
         # @return [Array<Events::Event>] if hold end event is detected
         # @return [NilClass] if event is NOT detected
+        #: (Array[untyped]) -> Fusuma::Plugin::Events::Event?
         def detect(buffers)
           hold_buffer = find_hold_buffer(buffers)
           return if hold_buffer.empty?
@@ -77,6 +79,7 @@ module Fusuma
 
         # @param [Integer] finger
         # @return [Config::Index]
+        #: (finger: Integer) -> Fusuma::Config::Index
         def create_oneshot_index(finger:)
           Config::Index.new(
             [
@@ -88,6 +91,7 @@ module Fusuma
 
         # @param [Integer] finger
         # @return [Config::Index]
+        #: (finger: Integer, status: String) -> Fusuma::Config::Index
         def create_repeat_index(finger:, status:)
           Config::Index.new(
             [
@@ -102,12 +106,14 @@ module Fusuma
 
         # @param buffers [Array<Buffers::Buffer>]
         # @return [Buffers::GestureBuffer]
+        #: (Array[untyped]) -> Fusuma::Plugin::Buffers::GestureBuffer
         def find_hold_buffer(buffers)
           buffers.find { |b| b.type == BUFFER_TYPE }
             .select_from_last_begin
             .select_by_type(GESTURE_RECORD_TYPE)
         end
 
+        #: (hold_events: Array[untyped], last_timer: nil | Fusuma::Plugin::Events::Event) -> Float
         def calc_holding_time(hold_events:, last_timer:)
           last_time = if last_timer && (hold_events.last.time < last_timer.time)
             last_timer.time
@@ -117,16 +123,18 @@ module Fusuma
           last_time - hold_events.first.time
         end
 
+        #: (index: Fusuma::Config::Index, holding_time: Float) -> bool
         def enough?(index:, holding_time:)
           diff = threshold(index: index) - holding_time
           if diff < 0
-            true
+            return true
           elsif diff < @timer.interval
             @timer.wake_early(Time.now + diff)
-            false
           end
+          false
         end
 
+        #: (index: Fusuma::Config::Index) -> Float
         def threshold(index:)
           @threshold ||= {}
           @threshold[index.cache_key] ||= begin

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

@@ -16,6 +16,7 @@ module Fusuma
         # @param buffers [Array<Buffer>]
         # @return [Events::Event] if event is detected
         # @return [NilClass] if event is NOT detected
+        #: (Array[untyped]) -> (Fusuma::Plugin::Events::Event | Array[untyped])?
         def detect(buffers)
           gesture_buffer = buffers.find { |b| b.type == BUFFER_TYPE }
             .select_from_last_begin
@@ -53,7 +54,7 @@ module Fusuma
           delta = event.record.delta
           prev_delta = prev_event.record.delta
 
-          repeat_direction = Direction.new(target: delta.zoom, base: (prev_delta&.zoom || 1.0)).to_s
+          repeat_direction = Direction.new(target: delta.zoom, base: prev_delta&.zoom || 1.0).to_s
           # repeat_quantity = Quantity.new(target: delta.zoom, base: (prev_delta&.zoom || 1.0)).to_f
 
           repeat_index = create_repeat_index(gesture: type, finger: finger,
@@ -97,6 +98,7 @@ module Fusuma
         # @param [String] direction
         # @param [String] status
         # @return [Config::Index]
+        #: (gesture: String, finger: Integer, direction: String, status: String) -> Fusuma::Config::Index
         def create_repeat_index(gesture:, finger:, direction:, status:)
           Config::Index.new(
             [
@@ -112,6 +114,7 @@ module Fusuma
         # @param [Integer] finger
         # @param [String] direction
         # @return [Config::Index]
+        #: (gesture: String, finger: Integer, direction: String) -> Fusuma::Config::Index
         def create_oneshot_index(gesture:, finger:, direction:)
           Config::Index.new(
             [
@@ -124,16 +127,19 @@ module Fusuma
 
         private
 
+        #: (Fusuma::Plugin::Events::Event, Fusuma::Plugin::Events::Event) -> bool
         def moved?(prev_event, event)
           zoom_delta = (event.record.delta.zoom - prev_event.record.delta.zoom).abs
           updating_time = (event.time - prev_event.time) * 100
           zoom_delta / updating_time > 0.01
         end
 
+        #: (index: Fusuma::Config::Index, quantity: Float) -> bool
         def enough_oneshot_threshold?(index:, quantity:)
           quantity >= threshold(index: index)
         end
 
+        #: (index: Fusuma::Config::Index) -> Float
         def threshold(index:)
           @threshold ||= {}
           @threshold[index.cache_key] ||= begin
@@ -150,15 +156,18 @@ module Fusuma
           IN = "in"
           OUT = "out"
 
+          #: (target: Float, base: Integer | Float) -> void
           def initialize(target:, base:)
             @target = target.to_f
             @base = base.to_f
           end
 
+          #: () -> String
           def to_s
             calc
           end
 
+          #: () -> String
           def calc
             if @target > @base
               OUT
@@ -170,15 +179,18 @@ module Fusuma
 
         # quantity of gesture
         class Quantity
+          #: (target: Float, base: Float) -> void
           def initialize(target:, base:)
             @target = target.to_f
             @base = base.to_f
           end
 
+          #: () -> Float
           def to_f
             calc.to_f
           end
 
+          #: () -> Float
           def calc
             if @target > @base
               @target / @base

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

@@ -16,6 +16,7 @@ module Fusuma
         # @param buffers [Array<Buffer>]
         # @return [Events::Event] if event is detected
         # @return [NilClass] if event is NOT detected
+        #: (Array[untyped]) -> (Fusuma::Plugin::Events::Event | Array[untyped])?
         def detect(buffers)
           gesture_buffer = buffers.find { |b| b.type == BUFFER_TYPE }
             .select_from_last_begin
@@ -84,6 +85,7 @@ module Fusuma
         # @param [String] direction
         # @param [String] status
         # @return [Config::Index]
+        #: (gesture: String, finger: Integer, direction: String, status: String) -> Fusuma::Config::Index
         def create_repeat_index(gesture:, finger:, direction:, status:)
           Config::Index.new(
             [
@@ -99,6 +101,7 @@ module Fusuma
         # @param [Integer] finger
         # @param [String] direction
         # @return [Config::Index]
+        #: (gesture: String, finger: Integer, direction: String) -> Fusuma::Config::Index
         def create_oneshot_index(gesture:, finger:, direction:)
           Config::Index.new(
             [
@@ -111,14 +114,17 @@ module Fusuma
 
         private
 
+        #: (Float) -> bool
         def moved?(repeat_quantity)
           repeat_quantity > 0.2
         end
 
+        #: (index: Fusuma::Config::Index, quantity: Float) -> bool
         def enough_oneshot_threshold?(index:, quantity:)
           quantity > threshold(index: index)
         end
 
+        #: (index: Fusuma::Config::Index) -> Float
         def threshold(index:)
           @threshold ||= {}
           @threshold[index.cache_key] ||= begin
@@ -135,14 +141,17 @@ module Fusuma
           CLOCKWISE = "clockwise"
           COUNTERCLOCKWISE = "counterclockwise"
 
+          #: (angle: Float) -> void
           def initialize(angle:)
             @angle = angle.to_f
           end
 
+          #: () -> String
           def to_s
             calc
           end
 
+          #: () -> String
           def calc
             if @angle.positive?
               CLOCKWISE
@@ -154,10 +163,12 @@ module Fusuma
 
         # quantity of gesture
         class Quantity
+          #: (angle: Float) -> void
           def initialize(angle:)
             @angle = angle.abs
           end
 
+          #: () -> Float
           def to_f
             @angle.to_f
           end

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

@@ -16,6 +16,7 @@ module Fusuma
         # @param buffers [Array<Buffers::Buffer>]
         # @return [Events::Event] if event is detected
         # @return [NilClass] if event is NOT detected
+        #: (Array[untyped]) -> (Fusuma::Plugin::Events::Event | Array[untyped])?
         def detect(buffers)
           gesture_buffer = buffers.find { |b| b.type == BUFFER_TYPE }
             .select_from_last_begin
@@ -82,6 +83,7 @@ module Fusuma
         # @param [String] direction
         # @param [String] status
         # @return [Config::Index]
+        #: (gesture: String, finger: Integer, direction: String, status: String) -> Fusuma::Config::Index
         def create_repeat_index(gesture:, finger:, direction:, status:)
           Config::Index.new(
             [
@@ -97,6 +99,7 @@ module Fusuma
         # @param [Integer] finger
         # @param [String] direction
         # @return [Config::Index]
+        #: (gesture: String, finger: Integer, direction: String) -> Fusuma::Config::Index
         def create_oneshot_index(gesture:, finger:, direction:)
           Config::Index.new(
             [
@@ -109,14 +112,17 @@ module Fusuma
 
         private
 
+        #: (Float) -> bool
         def moved?(repeat_quantity)
           repeat_quantity > 0.3
         end
 
+        #: (index: Fusuma::Config::Index, quantity: Float) -> bool
         def enough_oneshot_threshold?(index:, quantity:)
           quantity > threshold(index: index)
         end
 
+        #: (index: Fusuma::Config::Index) -> Integer
         def threshold(index:)
           @threshold ||= {}
           @threshold[index.cache_key] ||= begin
@@ -135,15 +141,18 @@ module Fusuma
           DOWN = "down"
           UP = "up"
 
+          #: (move_x: Integer | Float, move_y: Integer | Float) -> void
           def initialize(move_x:, move_y:)
             @move_x = move_x.to_f
             @move_y = move_y.to_f
           end
 
+          #: () -> String
           def to_s
             calc
           end
 
+          #: () -> String
           def calc
             if @move_x.abs > @move_y.abs
               @move_x.positive? ? RIGHT : LEFT
@@ -157,15 +166,18 @@ module Fusuma
 
         # quantity of gesture
         class Quantity
+          #: (move_x: Integer | Float, move_y: Integer | Float) -> void
           def initialize(move_x:, move_y:)
             @x = move_x.to_f.abs
             @y = move_y.to_f.abs
           end
 
+          #: () -> Float
           def to_f
             calc.to_f
           end
 
+          #: () -> Float
           def calc
             (@x > @y) ? @x.abs : @y.abs
           end