fusuma 1.11.1 → 2.0.2

data/lib/fusuma/config/index.rb

@@ -19,6 +19,11 @@ module Fusuma
                   [Key.new(keys)]
                 end
       end
+
+      def inspect
+        @keys.map(&:inspect)
+      end
+
       attr_reader :keys
 
       def cache_key
@@ -32,17 +37,45 @@ module Fusuma
         end
       end
 
+      # @return [Index]
+      def with_context
+        keys = @keys.map do |key|
+          next if Searcher.skip? && key.skippable
+
+          if Searcher.fallback? && key.fallback
+            key.fallback
+          else
+            key
+          end
+        end
+        self.class.new(keys.compact)
+      end
+
       # Keys in Index
       class Key
-        def initialize(symbol_word, skippable: false)
+        def initialize(symbol_word, skippable: false, fallback: nil)
           @symbol = begin
-                      symbol_word.to_sym
-                    rescue StandardError
-                      symbol_word
-                    end
+            symbol_word.to_sym
+          rescue StandardError
+            symbol_word
+          end
+
           @skippable = skippable
+
+          @fallback = begin
+            fallback.to_sym
+          rescue StandardError
+            fallback
+          end
         end
-        attr_reader :symbol, :skippable
+
+        def inspect
+          skip_marker = @skippable && Searcher.skip? ? '(skip)' : ''
+          fallback_marker = @fallback && Searcher.fallback? ? '(fallback)' : ''
+          "#{@symbol}#{skip_marker}#{fallback_marker}"
+        end
+
+        attr_reader :symbol, :skippable, :fallback
       end
     end
   end

data/lib/fusuma/config/searcher.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+# Index for searching value from config.yml
+module Fusuma
+  class Config
+    # Search config.yml
+    class Searcher
+      def initialize
+        @cache = nil
+      end
+
+      # @param index [Index]
+      # @param location [Hash]
+      # @return [NilClass]
+      # @return [Hash]
+      # @return [Object]
+      def search(index, location:)
+        key = index.keys.first
+        return location if key.nil?
+
+        return nil if location.nil?
+
+        return nil unless location.is_a?(Hash)
+
+        next_index = Index.new(index.keys[1..-1])
+
+        value = nil
+        next_location_cadidates(location, key).find do |next_location|
+          value = search(next_index, location: next_location)
+        end
+        value
+      end
+
+      def search_with_context(index, location:, context:)
+        return nil if location.nil?
+
+        return search(index, location: location[0]) if context == {}
+
+        new_location = location.find do |conf|
+          search(index, location: conf) if conf[:context] == context
+        end
+        search(index, location: new_location)
+      end
+
+      # @param index [Index]
+      # @param location [Hash]
+      # @return [NilClass]
+      # @return [Hash]
+      # @return [Object]
+      def search_with_cache(index, location:)
+        cache([index.cache_key, Searcher.context, Searcher.skip?, Searcher.fallback?]) do
+          search_with_context(index, location: location, context: Searcher.context)
+        end
+      end
+
+      def cache(key)
+        @cache ||= {}
+        key = key.join(',') if key.is_a? Array
+        if @cache.key?(key)
+          @cache[key]
+        else
+          @cache[key] = block_given? ? yield : nil
+        end
+      end
+
+      private
+
+      # next locations' candidates sorted by priority
+      #  1. look up location with key
+      #  2. fallback to other key
+      #  3. skip the key and go to child location
+      def next_location_cadidates(location, key)
+        [
+          location[key.symbol],
+          Searcher.skip? && key.skippable && location
+        ].compact
+      end
+
+      class << self
+        # @return [Hash]
+        def conditions(&block)
+          {
+            nothing: -> { block.call },
+            skip: -> { Config::Searcher.skip { block.call } }
+          }
+        end
+
+        # Execute block with specified conditions
+        # @param conidtion [Symbol]
+        # @return [Object]
+        def with_condition(condition, &block)
+          conditions(&block)[condition].call
+        end
+
+        # Execute block with all conditions
+        # @return [Array<Symbol, Object>]
+        def find_condition(&block)
+          conditions(&block).find do |c, l|
+            result = l.call
+            return [c, result] if result
+
+            nil
+          end
+        end
+
+        # Search with context from load_streamed Config
+        # @param context [Hash]
+        # @return [Object]
+        def with_context(context, &block)
+          @context = context || {}
+          result = block.call
+          @context = {}
+          result
+        end
+
+        # Return a matching context from config
+        # @params request_context [Hash]
+        # @return [Hash]
+        def find_context(request_context, &block)
+          # Search in blocks in the following order.
+          # 1. complete match config[:context] == request_context
+          # 2. partial match config[:context] =~ request_context
+          # 3. no context
+          Config.instance.keymap.each do |config|
+            next unless config[:context] == request_context
+            return config[:context] if with_context(config[:context]) { block.call }
+          end
+          if request_context.keys.size > 1
+            Config.instance.keymap.each do |config|
+              next if config[:context].nil?
+
+              next unless config[:context].all? { |k, v| request_context[k] == v }
+              return config[:context] if with_context(config[:context]) { block.call }
+            end
+          end
+          return {} if with_context({}) { block.call }
+        end
+
+        attr_reader :context
+
+        def fallback?
+          @fallback
+        end
+
+        def skip?
+          @skip
+        end
+
+        # switch context for fallback
+        def fallback(&block)
+          @fallback = true
+          result = block.call
+          @fallback = false
+          result
+        end
+
+        def skip(&block)
+          @skip = true
+          result = block.call
+          @skip = false
+          result
+        end
+      end
+    end
+  end
+end

data/lib/fusuma/custom_process.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Fusuma
+  # Rename process
+  module CustomProcess
+    def fork
+      Process.fork do
+        Process.setproctitle(self.class.name.underscore.to_s)
+        yield
+      end
+    end
+  end
+end

data/lib/fusuma/device.rb

@@ -1,18 +1,17 @@
 # frozen_string_literal: true
 
 require_relative './multi_logger'
-require_relative './libinput_command.rb'
+require_relative './libinput_command'
 
 module Fusuma
   # detect input device
   class Device
-    attr_reader :available
-    attr_reader :name
-    attr_reader :id
+    attr_reader :id, :name, :capabilities, :available
 
-    def initialize(id: nil, name: nil, available: nil)
+    def initialize(id: nil, name: nil, capabilities: nil, available: nil)
       @id = id
       @name = name
+      @capabilities = capabilities
       @available = available
     end
 
@@ -24,6 +23,8 @@ module Fusuma
           @id = v
         when :name
           @name = v
+        when :capabilities
+          @capabilities = v
         when :available
           @available = v
         end
@@ -31,9 +32,13 @@ module Fusuma
     end
 
     class << self
+      # Return devices
+      # sort devices by capabilities of gesture
       # @return [Array]
       def all
-        @all ||= fetch_devices
+        @all ||= fetch_devices.partition do |d|
+          d.capabilities.match?(/gesture/)
+        end.flatten
       end
 
       # @raise [SystemExit]
@@ -59,7 +64,9 @@ module Fusuma
       # @return [Array]
       def fetch_devices
         line_parser = LineParser.new
-        LibinputCommand.new.list_devices do |line|
+
+        libinput_command = Plugin::Inputs::LibinputCommandInput.new.command
+        libinput_command.list_devices do |line|
           line_parser.push(line)
         end
         line_parser.generate_devices
@@ -102,6 +109,8 @@ module Fusuma
           { id: id }
         elsif (name = name_from(line))
           { name: name }
+        elsif (capabilities = capabilities_from(line))
+          { capabilities: capabilities }
         elsif (available = available_from(line))
           { available: available }
         else
@@ -121,6 +130,12 @@ module Fusuma
         end
       end
 
+      def capabilities_from(line)
+        line.match('^Capabilities:[[:space:]]*') do |m|
+          m.post_match.strip
+        end
+      end
+
       def available_from(line)
         # NOTE: is natural scroll available?
         if line =~ /^Nat.scrolling: /

data/lib/fusuma/environment.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require_relative './version.rb'
-require_relative './libinput_command.rb'
-require_relative './multi_logger.rb'
+require_relative './version'
+require_relative './libinput_command'
+require_relative './multi_logger'
 
 module Fusuma
   # Output Environment information
@@ -17,8 +17,10 @@ module Fusuma
       end
 
       def print_version
+        libinput_command = Plugin::Inputs::LibinputCommandInput.new.command
         MultiLogger.info "Fusuma: #{VERSION}"
-        MultiLogger.info "libinput: #{LibinputCommand.new.version}"
+        MultiLogger.info "libinput: #{libinput_command.version}"
+        MultiLogger.info "ruby #{ RUBY_VERSION }p#{ RUBY_PATCHLEVEL }"
         MultiLogger.info "OS: #{`uname -rsv`}".strip
         MultiLogger.info "Distribution: #{`cat /etc/issue`}".strip
         MultiLogger.info "Desktop session: #{`echo $DESKTOP_SESSION $XDG_SESSION_TYPE`}".strip

data/lib/fusuma/hash_support.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+# Patch to hash
+class Hash
+  # activesupport-4.1.1/lib/active_support/core_ext/hash/keys.rb
+  def deep_symbolize_keys
+    deep_transform_keys do |key|
+      key.to_sym
+    rescue StandardError
+      key
+    end
+  end
+
+  def deep_transform_keys(&block)
+    result = {}
+    each do |key, value|
+      result[yield(key)] = value.is_a?(Hash) ? value.deep_transform_keys(&block) : value
+    end
+    result
+  end
+
+  # activesupport/lib/active_support/core_ext/hash/deep_transform_values.rb
+  def deep_transform_values(&block)
+    _deep_transform_values_in_object(self, &block)
+  end
+
+  private
+
+  # Support methods for deep transforming nested hashes and arrays.
+  def _deep_transform_values_in_object(object, &block)
+    case object
+    when Hash
+      object.transform_values { |value| _deep_transform_values_in_object(value, &block) }
+    when Array
+      object.map { |e| _deep_transform_values_in_object(e, &block) }
+    else
+      yield(object)
+    end
+  end
+end

data/lib/fusuma/libinput_command.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
-require 'open3'
-require 'timeout'
+require 'posix/spawn'
 
 module Fusuma
   # Execute libinput command
@@ -31,40 +30,37 @@ module Fusuma
     end
 
     # @yieldparam [String] gives a line in libinput list-devices output to the block
-    def list_devices
+    def list_devices(&block)
       cmd = list_devices_command
       MultiLogger.debug(list_devices: cmd)
-      Open3.popen3(cmd) do |_i, o, _e, _w|
-        o.each { |line| yield(line) }
-      end
+      p, i, o, e = POSIX::Spawn.popen4(cmd)
+      i.close
+      o.each(&block)
+    ensure
+      [i, o, e].each { |io| io.close unless io.closed? }
+      Process.waitpid(p)
     end
 
-    # @yieldparam [String] gives a line in libinput debug-events output to the block
+    # @return [Integer, IO] return a latest line libinput debug-events
     def debug_events
-      MultiLogger.debug(debug_events: debug_events_with_options)
-      Open3.popen3(debug_events_with_options) do |_i, o, _e, _w|
-        loop do
-          line = begin
-                   Timeout.timeout(wait_time) do
-                     o.readline.chomp
-                   end
-                 rescue Timeout::Error
-                   TIMEOUT_MESSAGE
-                 end
-          yield(line)
-        end
+      @debug_events = begin
+        p, i, o, _e = POSIX::Spawn.popen4(debug_events_with_options)
+        i.close
+        [p, o]
       end
     end
 
     # @return [String] command
     # @raise [SystemExit]
     def version_command
-      if which('libinput')
+      if @debug_events_command && @list_devices_command
+        "#{@list_devices_command} --version"
+      elsif which('libinput')
         'libinput --version'
       elsif which('libinput-list-devices')
         'libinput-list-devices --version'
       else
-        MultiLogger.error 'install libinput-tools'
+        MultiLogger.error 'Please install libinput-tools'
         exit 1
       end
     end