fusuma 2.0.0.pre → 2.0.3

data/lib/fusuma/config/searcher.rb

@@ -6,7 +6,7 @@ module Fusuma
     # Search config.yml
     class Searcher
       def initialize
-        @cache
+        @cache = nil
       end
 
       # @param index [Index]
@@ -31,9 +31,25 @@ module Fusuma
         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.skip?, Searcher.fallback?]) do
-          search(index, location: location)
+        cache([index.cache_key, Searcher.context, Searcher.skip?, Searcher.fallback?]) do
+          search_with_context(index, location: location, context: Searcher.context)
         end
       end
 
@@ -56,12 +72,72 @@ module Fusuma
       def next_location_cadidates(location, key)
         [
           location[key.symbol],
-          Searcher.fallback? && key.fallback && location[key.fallback],
           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

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]
@@ -104,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
@@ -123,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
@@ -20,6 +20,7 @@ module Fusuma
         libinput_command = Plugin::Inputs::LibinputCommandInput.new.command
         MultiLogger.info "Fusuma: #{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,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'posix/spawn'
+require 'open3'
 
 module Fusuma
   # Execute libinput command
@@ -30,24 +30,19 @@ 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)
-      p, i, o, e = POSIX::Spawn.popen4(cmd)
+      i, o, e, _w = Open3.popen3(cmd)
+      MultiLogger.error(e.read) if o.eof?
       i.close
-      o.each { |line| yield(line) }
-    ensure
-      [i, o, e].each { |io| io.close unless io.closed? }
-      Process.waitpid(p)
+      e.close
+      o.each(&block)
     end
 
-    # @return [String] return a latest line libinput debug-events
-    def debug_events
-      @debug_events ||= begin
-                          _p, i, o, _e = POSIX::Spawn.popen4(debug_events_with_options)
-                          i.close
-                          o
-                        end
+    # @return [Integer] return a latest line libinput debug-events
+    def debug_events(writer)
+      @debug_events ||= Process.spawn(debug_events_with_options, out: writer, in: '/dev/null')
     end
 
     # @return [String] command
@@ -60,7 +55,7 @@ module Fusuma
       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

data/lib/fusuma/multi_logger.rb

@@ -12,15 +12,11 @@ module Fusuma
     attr_accessor :debug_mode
 
     def initialize
-      super(STDOUT)
-      @err_logger = Logger.new(STDERR)
+      super($stdout)
+      @err_logger = Logger.new($stderr)
       @debug_mode = false
     end
 
-    def info(msg)
-      super(msg)
-    end
-
     def debug(msg)
       return unless debug_mode?
 

data/lib/fusuma/plugin/base.rb

@@ -1,22 +1,23 @@
 # frozen_string_literal: true
 
-require_relative './manager.rb'
-require_relative '../config.rb'
+require_relative './manager'
+require_relative '../config'
+require_relative '../custom_process'
 
 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
         subclass_path = caller_locations(1..1).first.path
         Manager.add(plugin_class: subclass, plugin_path: subclass_path)
       end
 
-      # get inherited classes
-      # @example
-      #  [Vectors::Vector]
-      # @return [Array]
+      # get subclasses
+      # @return [Array<Class>]
       def self.plugins
         Manager.plugins[name]
       end
@@ -33,19 +34,21 @@ module Fusuma
 
         return params unless key
 
-        params.fetch(key, nil).tap do |val|
-          next if val.nil?
+        @config_params ||= {}
+        @config_params["#{base.cache_key},#{key}"] ||=
+          params.fetch(key, nil).tap do |val|
+            next if val.nil?
 
-          # NOTE: Type checking for config.yml
-          param_types = Array(config_param_types.fetch(key))
+            # NOTE: Type checking for config.yml
+            param_types = Array(config_param_types.fetch(key))
 
-          next if param_types.any? { |klass| val.is_a?(klass) }
+            next if param_types.any? { |klass| val.is_a?(klass) }
 
-          MultiLogger.error('Please fix config.yml.')
-          MultiLogger.error(":#{base.keys.map(&:symbol)
+            MultiLogger.error('Please fix config.yml.')
+            MultiLogger.error(":#{base.keys.map(&:symbol)
             .join(' => :')} => :#{key} should be #{param_types.join(' OR ')}.")
-          exit 1
-        end
+            exit 1
+          end
       end
 
       def config_index

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative '../base.rb'
+require_relative '../base'
 
 module Fusuma
   module Plugin
@@ -8,6 +8,7 @@ module Fusuma
       # buffer events and output
       class Buffer < Base
         def initialize(*args)
+          super()
           @events = Array.new(*args)
         end
 
@@ -15,7 +16,7 @@ module Fusuma
 
         # @return [String]
         def type
-          self.class.name.underscore.split('/').last.gsub('_buffer', '')
+          @type ||= self.class.name.underscore.split('/').last.gsub('_buffer', '')
         end
 
         # @param event [Event]

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative './buffer.rb'
+require_relative './buffer'
 
 module Fusuma
   module Plugin
@@ -8,17 +8,17 @@ module Fusuma
       # manage events and generate command
       class GestureBuffer < Buffer
         DEFAULT_SOURCE = 'libinput_gesture_parser'
-        DEFAULT_SECONDS_TO_KEEP = 0.1
+        DEFAULT_SECONDS_TO_KEEP = 100
 
         def config_param_types
           {
-            'source': [String],
-            'seconds_to_keep': [Float, Integer]
+            source: [String],
+            seconds_to_keep: [Float, Integer]
           }
         end
 
         # @param event [Event]
-        # @return [Buffer, false]
+        # @return [Buffer, FalseClass]
         def buffer(event)
           # TODO: buffering events into buffer plugins
           # - gesture event buffer
@@ -26,16 +26,13 @@ module Fusuma
           # - other event buffer
           return if event&.tag != source
 
-          if bufferable?(event)
-            @events.push(event)
-            self
-          else
-            clear
-            false
-          end
+          @events.push(event)
+          self
         end
 
         def clear_expired(current_time: Time.now)
+          clear if ended?
+
           @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
@@ -46,17 +43,28 @@ module Fusuma
           end
         end
 
+        def ended?
+          return false if empty?
+
+          @events.last.record.status == 'end'
+        end
+
         # @param attr [Symbol]
         # @return [Float]
         def sum_attrs(attr)
-          @events.map { |gesture_event| gesture_event.record.direction[attr].to_f }
-                 .inject(:+)
+          updating_events.map do |gesture_event|
+            gesture_event.record.delta[attr].to_f
+          end.inject(:+)
+        end
+
+        def updating_events
+          @events.select { |e| e.record.status == 'update' }
         end
 
         # @param attr [Symbol]
         # @return [Float]
         def avg_attrs(attr)
-          sum_attrs(attr).to_f / @events.length
+          sum_attrs(attr).to_f / updating_events.length
         end
 
         # return [Integer]
@@ -76,20 +84,21 @@ module Fusuma
           @events.empty?
         end
 
-        def select_by_events
-          return enum_for(:select) unless block_given?
+        def select_by_events(&block)
+          return enum_for(:select_by_events) unless block_given?
 
-          events = @events.select { |event| yield event }
+          events = @events.select(&block)
           self.class.new events
         end
 
-        def bufferable?(event)
-          case event.record.status
-          when 'begin', 'end'
-            false
-          else
-            true
-          end
+        def select_from_last_begin
+          return self if empty?
+
+          index_from_last = @events.reverse.find_index { |e| e.record.status == 'begin' }
+          return GestureBuffer.new([]) if index_from_last.nil?
+
+          index_last_begin = events.length - index_from_last - 1
+          GestureBuffer.new(@events[index_last_begin..-1])
         end
       end
     end