fusuma 2.0.0.pre → 2.0.0.pre2

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,23 +37,44 @@ 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, 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
+            fallback.to_sym
+          rescue StandardError
+            fallback
+          end
         end
+
+        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

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,23 @@ module Fusuma
         value
       end
 
+      def search_with_context(index, location:, context:)
+        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 +70,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.sort_by do |d|
+          d.capabilities.match(/gesture/).to_s
+        end
       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

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

@@ -30,24 +30,24 @@ 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.close
-      o.each { |line| yield(line) }
+      o.each(&block)
     ensure
       [i, o, e].each { |io| io.close unless io.closed? }
       Process.waitpid(p)
     end
 
-    # @return [String] return a latest line libinput debug-events
+    # @return [Integer, IO] 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
+      @debug_events = begin
+        p, i, o, _e = POSIX::Spawn.popen4(debug_events_with_options)
+        i.close
+        [p, o]
+      end
     end
 
     # @return [String] command

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]