fusuma 0.11.1 → 1.0

data/lib/fusuma/config.rb

@@ -1,88 +1,69 @@
+# frozen_string_literal: true
+
+require_relative './multi_logger.rb'
+require_relative './config/index.rb'
+require 'singleton'
+require 'yaml'
+
 # module as namespace
 module Fusuma
-  require 'singleton'
   # read keymap from yaml file
   class Config
     include Singleton
 
     class << self
-      def command(command_executor)
-        instance.command(command_executor)
+      def search(keys)
+        instance.search(keys)
       end
 
-      def shortcut(command_executor)
-        instance.shortcut(command_executor)
-      end
-
-      def threshold(command_executor)
-        instance.threshold(command_executor)
-      end
-
-      def interval(command_executor)
-        instance.interval(command_executor)
-      end
-
-      def reload
-        instance.reload
+      def custom_path=(new_path)
+        instance.custom_path = new_path
       end
     end
 
     attr_reader :keymap
-    attr_accessor :custom_path
+    attr_reader :custom_path
 
     def initialize
-      self.custom_path = nil
+      @custom_path = nil
+      @cache = nil
+      @keymap = nil
+      reload
+    end
+
+    def custom_path=(new_path)
+      @custom_path = new_path
       reload
     end
 
     def reload
       @cache  = nil
-      @keymap = YAML.load_file(file_path)
+      @keymap = YAML.load_file(file_path).deep_symbolize_keys
+      MultiLogger.info "reload config : #{file_path}"
       self
     end
 
-    def command(command_executor)
-      seek_index = [*event_index(command_executor), 'command']
-      search_config_cached(seek_index)
-    end
-
-    def shortcut(command_executor)
-      seek_index = [*event_index(command_executor), 'shortcut']
-      search_config_cached(seek_index)
-    end
-
-    def threshold(command_executor)
-      seek_index_specific = [*event_index(command_executor), 'threshold']
-      seek_index_global = ['threshold', command_executor.event_type]
-      search_config_cached(seek_index_specific) ||
-        search_config_cached(seek_index_global) || 1
-    end
-
-    def interval(command_executor)
-      seek_index_specific = [*event_index(command_executor), 'interval']
-      seek_index_global = ['interval', command_executor.event_type]
-      search_config_cached(seek_index_specific) ||
-        search_config_cached(seek_index_global) || 1
+    # @param index [Index]
+    def search(index)
+      cache(index.cache_key) do
+        index.keys.reduce(keymap) do |location, key|
+          if location.is_a?(Hash)
+            begin
+              if key.skippable
+                location.fetch(key.symbol, location)
+              else
+                location.fetch(key.symbol, nil)
+              end
+            end
+          else
+            location
+          end
+        end
+      end
     end
 
     private
 
-    def search_config_cached(seek_index)
-      cache(seek_index) { search_config(keymap, seek_index) }
-    end
-
-    def search_config(keymap_node, seek_index)
-      if seek_index == []
-        return nil if keymap_node.is_a? Hash
-        return keymap_node
-      end
-      key = seek_index[0]
-      child_node = keymap_node[key]
-      next_index = seek_index[1..-1]
-      return search_config(child_node, next_index) if child_node
-      search_config(keymap_node, next_index)
-    end
-
     def file_path
       filename = 'fusuma/config.yml'
       if custom_path && File.exist?(expand_custom_path)
@@ -106,17 +87,35 @@ module Fusuma
       File.expand_path "../../#{filename}", __FILE__
     end
 
-    def event_index(command_executor)
-      event_type = command_executor.event_type
-      finger      = command_executor.finger
-      direction   = command_executor.direction
-      [event_type, finger, direction]
-    end
-
     def cache(key)
       @cache ||= {}
       key = key.join(',') if key.is_a? Array
-      @cache[key] ||= block_given? ? yield : nil
+      if @cache.key?(key)
+        @cache[key]
+      else
+        @cache[key] = block_given? ? yield : nil
+      end
+    end
+  end
+end
+
+# activesupport-4.1.1/lib/active_support/core_ext/hash/keys.rb
+class Hash
+  def deep_symbolize_keys
+    deep_transform_keys do |key|
+      begin
+        key.to_sym
+      rescue StandardError
+        key
+      end
+    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
 end

data/lib/fusuma/config/index.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+# Index for searching value from config.yml
+module Fusuma
+  class Config
+    # index for config.yml
+    class Index
+      def initialize(keys)
+        @keys = case keys
+                when Array
+                  keys.map do |key|
+                    if key.is_a? Key
+                      key
+                    else
+                      Key.new(key)
+                    end
+                  end
+                else
+                  [Key.new(keys)]
+                end
+      end
+      attr_reader :keys
+
+      def cache_key
+        case @keys
+        when Array
+          @keys.map(&:symbol).join(',')
+        when Key
+          @keys.symbol
+        else
+          raise 'invalid keys'
+        end
+      end
+
+      # Keys in Index
+      class Key
+        def initialize(symbol_word, skippable: false)
+          @symbol = begin
+                      symbol_word.to_sym
+                    rescue StandardError
+                      symbol_word
+                    end
+          @skippable = skippable
+        end
+        attr_reader :symbol, :skippable
+      end
+    end
+  end
+end

data/lib/fusuma/device.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 module Fusuma
   # detect input device
   class Device
-    attr_accessor :id
-    attr_accessor :name
-    attr_accessor :available
+    attr_reader :available
+    attr_reader :name
+    attr_reader :id
 
     def initialize(id: nil, name: nil, available: nil)
       @id = id
@@ -11,68 +13,81 @@ module Fusuma
       @available = available
     end
 
-    # @param [Hash]
+    # @param attributes [Hash]
     def assign_attributes(attributes)
       attributes.each do |k, v|
         case k
         when :id
-          self.id = v
+          @id = v
         when :name
-          self.name = v
+          @name = v
         when :available
-          self.available = v
+          @available = v
         end
       end
     end
 
     class << self
-      # @return [Array]
-      def ids
-        available.map(&:id)
-      end
+      attr_reader :given_devices
 
       # @return [Array]
-      def names
-        available.map(&:name)
+      def all
+        @all ||= fetch_devices
       end
 
       # @raise [SystemExit]
       # @return [Array]
       def available
-        @available ||= fetch_available.tap do |d|
+        @available ||= all.select(&:available).tap do |d|
           MultiLogger.debug(available_devices: d)
           raise 'Touchpad is not found' if d.empty?
         end
-      rescue RuntimeError => ex
-        MultiLogger.error(ex.message)
+      rescue RuntimeError => e
+        # FIXME: should not exit without Runner class
+        MultiLogger.error(e.message)
         exit 1
       end
 
       def reset
+        @all = nil
         @available = nil
       end
 
-      # @param [String]
-      def given_device=(name)
-        return if name.nil?
-        @available = available.select { |d| d.name == name }
-        return unless names.empty?
-        MultiLogger.error("Device #{name} is not found.\n
-           Check available device with: $ fusuma --list-devices\n")
+      # Narrow down available device list
+      # @param names [String, Array]
+      def given_devices=(names)
+        # NOTE: convert to Array
+        device_names = Array(names)
+        return if device_names.empty?
+
+        @given_devices = narrow_available_devices(device_names: device_names)
+        return unless @given_devices.empty?
+
         exit 1
       end
 
       private
 
       # @return [Array]
-      def fetch_available
+      def fetch_devices
         line_parser = LineParser.new
-        LibinputCommands.new.list_devices do |line|
+        Plugin::Inputs::LibinputCommandInput.new.list_devices do |line|
           line_parser.push(line)
         end
         line_parser.generate_devices
       end
 
+      def narrow_available_devices(device_names:)
+        device_names.select do |name|
+          if available.map(&:name).include? name
+            MultiLogger.info("Touchpad is found: #{name}")
+            true
+          else
+            MultiLogger.warn("Touchpad is not found: #{name}")
+          end
+        end
+      end
+
       # parse line and generate devices
       class LineParser
         attr_reader :lines
@@ -88,25 +103,28 @@ module Fusuma
 
         # @return [Array]
         def generate_devices
-          device = nil
+          device = Device.new
           lines.each_with_object([]) do |line, devices|
-            device ||= Device.new
-            device.assign_attributes extract_attribute(line: line)
-            if device.available
+            attributes = extract_attribute(line: line)
+
+            # detect new line including device name
+            if attributes[:name] && (device&.name != attributes[:name])
               devices << device
-              device = nil
+              device = Device.new
             end
+
+            devices.last.assign_attributes(attributes)
           end
         end
 
-        # @param  [String]
+        # @param line [String]
         # @return [Hash]
         def extract_attribute(line:)
           if (id = id_from(line))
             { id: id }
           elsif (name = name_from(line))
             { name: name }
-          elsif (available = available?(line))
+          elsif (available = available_from(line))
             { available: available }
           else
             {}
@@ -125,11 +143,14 @@ module Fusuma
           end
         end
 
-        def available?(line)
-          # NOTE: natural scroll is available?
-          return false unless line =~ /^Nat.scrolling: /
-          return false if line =~ %r{n/a}
-          true
+        def available_from(line)
+          # NOTE: is natural scroll available?
+          if line =~ /^Nat.scrolling: /
+            return false if line =~ %r{n/a}
+
+            return true # disabled / enabled
+          end
+          nil
         end
       end
     end

data/lib/fusuma/multi_logger.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # module as namespace
 module Fusuma
   require 'logger'
@@ -21,6 +23,7 @@ module Fusuma
 
     def debug(msg)
       return unless debug_mode?
+
       super(msg)
     end
 

data/lib/fusuma/plugin/base.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative './manager.rb'
+require_relative '../config.rb'
+
+module Fusuma
+  module Plugin
+    # Create a Plugin Class with extending this class
+    class Base
+      # when inherited from subclass
+      def self.inherited(subclass)
+        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]
+      def self.plugins
+        Manager.plugins[name]
+      end
+
+      # config parameter name and Type of the value of parameter
+      # @return [Hash]
+      def config_param_types
+        raise NotImplementedError, "override #{self.class.name}##{__method__}"
+      end
+
+      # @return [Object]
+      def config_params(key = nil, base: config_index)
+        params = Config.search(base) || {}
+
+        return params unless 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))
+
+          next if param_types.any? { |klass| val.is_a?(klass) }
+
+          MultiLogger.error('Please fix config.yml.')
+          MultiLogger.error(":#{base.keys.map(&:symbol)
+            .join(' => :')} => :#{key} should be #{param_types.join(' OR ')}.")
+          exit 1
+        end
+      end
+
+      def config_index
+        Config::Index.new(self.class.name.gsub('Fusuma::', '').underscore.split('/'))
+      end
+    end
+  end
+end