fusuma 0.11.1 → 1.0

data/lib/fusuma/plugin/events/event.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative '../base.rb'
+require_relative './records/record.rb'
+require_relative './records/text_record.rb'
+
+module Fusuma
+  module Plugin
+    module Events
+      # Event format
+      class Event < Base
+        attr_reader :time
+        attr_accessor :tag, :record
+
+        # @param time [Time]
+        # @param tag [Tag]
+        # @param record [String, Record]
+        def initialize(time: Time.now, tag:, record:)
+          @time = time
+          @tag = tag
+          @record = case record
+                    when Records::Record
+                      record
+                    when String
+                      Records::TextRecord.new(record)
+                    else
+                      raise ArgumentError,
+                            '@record should be String or Record'
+                    end
+        end
+
+        def inspect
+          "time: #{time}, tag: #{tag}, record: #{record}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative './text_record.rb'
+
+module Fusuma
+  module Plugin
+    module Events
+      module Records
+        # Gesture Record
+        class GestureRecord < Record
+          # define gesture format
+          attr_reader :status, :gesture, :finger, :direction
+
+          Delta = Struct.new(:move_x, :move_y, :zoom, :rotate)
+
+          # @param status [String]
+          def initialize(status:, gesture:, finger:, direction:)
+            @status  = status
+            @gesture = gesture
+            @finger  = finger
+            @direction = direction
+          end
+
+          def type
+            :gesture
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Fusuma
+  module Plugin
+    module Events
+      module Records
+        # Vector Record
+        # have index
+        class IndexRecord < Record
+          # define gesture format
+          attr_reader :index
+
+          # @param [Config::Index] index
+          # @param [Symbol] position [:prefix, :body, :surfix]
+          def initialize(index:, position: :body)
+            @index = index
+            @position = position
+          end
+
+          def type
+            :index
+          end
+
+          # @param records [Array<IndexRecord>]
+          # @return [IndexRecord]
+          def merge(records:)
+            raise "position is NOT body: #{self}" unless mergable?
+
+            @index = records.each_with_object(@index) do |record, merged_index|
+              case record.position
+              when :prefix
+                Index.new([*record.index.keys, *merged_index.keys])
+              when :surfix
+                Index.new([*merged_index.keys, *record.index.keys])
+              else
+                raise "invalid index position: #{record}"
+              end
+            end
+            self
+          end
+
+          def mergable?
+            @position == :body
+          end
+
+          protected
+
+          attr_reader :position
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative '../../base.rb'
+
+module Fusuma
+  module Plugin
+    module Events
+      module Records
+        # Record
+        # @abstract Subclass and override {#type} to implement
+        class Record < Base
+          # @return [Symbol]
+          def type
+            raise NotImplementedError, 'override #type'
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative './record.rb'
+
+module Fusuma
+  module Plugin
+    module Events
+      module Records
+        # Default Record
+        class TextRecord < Record
+          # @param text [String]
+          def initialize(text)
+            @text = text
+          end
+
+          def type
+            :text
+          end
+
+          # @return [String]
+          def to_s
+            @text
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative './executor.rb'
+
+module Fusuma
+  module Plugin
+    module Executors
+      # Exector plugin
+      class CommandExecutor < Executor
+        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
+
+            Process.detach(pid)
+          end
+        end
+
+        def executable?(event)
+          event.tag.end_with?('_detector') &&
+            event.record.type == :index &&
+            search_command(event)
+        end
+
+        # @param event [Event]
+        # @return [String]
+        def search_command(event)
+          command_index = Config::Index.new([*event.record.index.keys, :command])
+          Config.search(command_index)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative '../base.rb'
+
+module Fusuma
+  module Plugin
+    # executor class
+    module Executors
+      # Inherite this base
+      class Executor < Base
+        # check executable
+        # @param _event [Event]
+        # @return [TrueClass, FalseClass]
+        def executable?(_event)
+          raise NotImplementedError, "override #{self.class.name}##{__method__}"
+        end
+
+        # execute somthing
+        # @param _event [Event]
+        # @return [nil]
+        def execute(_event)
+          raise NotImplementedError, "override #{self.class.name}##{__method__}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative '../base.rb'
+
+module Fusuma
+  module Plugin
+    # filter class
+    module Filters
+      # Inherite this base
+      class Filter < Base
+        # Filter input event
+        # @param event [Event]
+        # @return [Event, nil]
+        def filter(event)
+          event.tap do |e|
+            next if e.tag != source
+            next if keep?(e.record)
+
+            MultiLogger.debug(filtered: e)
+
+            break nil
+          end
+        end
+
+        # @abstract override `#keep?` to implement
+        # @param record [String]
+        # @return [True, False]
+        def keep?(record)
+          true if record
+        end
+
+        # Set source for tag from config.yml.
+        # DEFAULT_SOURCE is defined in each Filter plugins.
+        def source
+          @source ||= config_params(:source) || self.class.const_get('DEFAULT_SOURCE')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative './filter.rb'
+require_relative '../../device.rb'
+
+module Fusuma
+  module Plugin
+    module Filters
+      # Filter device log
+      class LibinputDeviceFilter < Filter
+        DEFAULT_SOURCE = 'libinput_command_input'
+
+        def config_param_types
+          {
+            source: String,
+            keep_device_names: [Array, String]
+          }
+        end
+
+        def keep?(record)
+          keep_device_ids.any? { |device_id| record.to_s =~ /^\s?#{device_id}/ }
+        end
+
+        private
+
+        # @return [Array]
+        def keep_device_ids
+          @keep_device_ids ||= Device.all.select do |device|
+            keep_device_names.any? { |name| device.name.match? name }
+          end.map(&:id)
+        end
+
+        # @return [Array]
+        def keep_device_names
+          Array(config_params(:keep_device_names)).tap do |names|
+            break Device.all.map(&:name) if names.empty?
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative '../base.rb'
+require_relative '../events/event.rb'
+
+module Fusuma
+  module Plugin
+    # input class
+    module Inputs
+      # Inherite this base
+      class Input < Base
+        def run
+          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
+        end
+
+        def tag
+          self.class.name.split('Inputs::').last.underscore
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require_relative './input.rb'
+require 'open3'
+
+module Fusuma
+  module Plugin
+    module Inputs
+      # libinput commands wrapper
+      class LibinputCommandInput < Input
+        def config_param_types
+          {
+            'enable-tap': [TrueClass, FalseClass],
+            'enable-dwt': [TrueClass, FalseClass],
+            'device': [String]
+          }
+        end
+
+        def run
+          debug_events do |line|
+            yield event(record: line)
+          end
+        end
+
+        # `libinput-list-devices` and `libinput-debug-events` are deprecated,
+        # use `libinput list-devices` and `libinput debug-events` from 1.8.
+        NEW_CLI_OPTION_VERSION = 1.8
+
+        # @return [Boolean]
+        def new_cli_option_available?
+          Gem::Version.new(version) >= Gem::Version.new(NEW_CLI_OPTION_VERSION)
+        end
+
+        # @return [String]
+        def version
+          # versiom_command prints "1.6.3\n"
+          @version ||= `#{version_command}`.strip
+        end
+
+        # @yield [line] gives a line in libinput list-devices output to the block
+        def list_devices
+          cmd = list_devices_command
+          MultiLogger.debug(list_devices: cmd)
+          Open3.popen3(cmd) do |_i, o, _e, _w|
+            o.each { |line| yield(line) }
+          end
+        end
+
+        # @yield [line] gives a line in libinput debug-events output to the block
+        def debug_events
+          prefix = 'stdbuf -oL --'
+          options = [*libinput_options, device_option]
+          cmd = "#{prefix} #{debug_events_command} #{options.join(' ')}".strip
+          MultiLogger.debug(debug_events: cmd)
+          Open3.popen3(cmd) do |_i, o, _e, _w|
+            o.each do |line|
+              yield(line.chomp)
+            end
+          end
+        end
+
+        # @return [String] command
+        # @raise [SystemExit]
+        def version_command
+          if which('libinput')
+            'libinput --version'
+          elsif which('libinput-list-devices')
+            'libinput-list-devices --version'
+          else
+            MultiLogger.error 'install libinput-tools'
+            exit 1
+          end
+        end
+
+        def list_devices_command
+          if new_cli_option_available?
+            'libinput list-devices'
+          else
+            'libinput-list-devices'
+          end
+        end
+
+        def debug_events_command
+          if new_cli_option_available?
+            'libinput debug-events'
+          else
+            'libinput-debug-events'
+          end
+        end
+
+        private
+
+        # use device option only if libinput detect only 1 device
+        # @return [String]
+        def device_option
+          return unless Device.available.size == 1
+
+          "--device=/dev/input/#{Device.available.first.id}"
+        end
+
+        # TODO: add specs
+        def libinput_options
+          enable_tap = '--enable-tap' if config_params(:'enable-tap')
+          device = ("--device=#{config_params(:device)}" if config_params(:device))
+          enable_dwt = '--enable-dwt' if config_params(:'enable-dwt')
+
+          [
+            enable_tap,
+            device,
+            enable_dwt
+          ].compact
+        end
+
+        # which in ruby: Checking if program exists in $PATH from ruby
+        # (https://stackoverflow.com/questions/2108727/which-in-ruby-checking-if-program-exists-in-path-from-ruby)
+        # Cross-platform way of finding an executable in the $PATH.
+        #
+        #   which('ruby') #=> /usr/bin/ruby
+        # @return [String, nil]
+        def which(command)
+          exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
+          ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
+            exts.each do |ext|
+              exe = File.join(path, "#{command}#{ext}")
+              return exe if File.executable?(exe) && !File.directory?(exe)
+            end
+          end
+          nil
+        end
+      end
+    end
+  end
+end