lib/fusuma.rb in fusuma-1.2.1 vs lib/fusuma.rb in fusuma-1.3.0

@@ -31,39 +31,38 @@
         load_custom_config(option[:config_path])
 
         Plugin::Manager.require_plugins_from_relative
         Plugin::Manager.require_plugins_from_config
 
-        print_version(then_exit: option[:version])
+        print_version
         print_enabled_plugins
+        Kernel.exit(0) if option[:version]
 
         print_device_list if option[:list]
         # TODO: remove keep_device_from_option from command line options
         Plugin::Filters::LibinputDeviceFilter::KeepDevice.from_option = option[:device]
         Process.daemon if option[:daemon]
       end
 
-      # TODO: print after reading plugins
-      def print_version(then_exit: false)
+      def print_version
         MultiLogger.info '---------------------------------------------'
         MultiLogger.info "Fusuma: #{Fusuma::VERSION}"
         MultiLogger.info "libinput: #{Plugin::Inputs::LibinputCommandInput.new.version}"
         MultiLogger.info "OS: #{`uname -rsv`}".strip
         MultiLogger.info "Distribution: #{`cat /etc/issue`}".strip
         MultiLogger.info "Desktop session: #{`echo $DESKTOP_SESSION`}".strip
         MultiLogger.info '---------------------------------------------'
-        Kernel.exit(0) if then_exit
       end
 
       def print_enabled_plugins
-        MultiLogger.debug '---------------------------------------------'
-        MultiLogger.debug 'Enabled Plugins: '
+        MultiLogger.info '---------------------------------------------'
+        MultiLogger.info 'Enabled Plugins: '
         Plugin::Manager.plugins
                        .reject { |k, _v| k.to_s =~ /Base/ }
                        .map { |_base, plugins| plugins.map { |plugin| "  #{plugin}" } }
-                       .flatten.sort.each { |name| MultiLogger.debug name }
-        MultiLogger.debug '---------------------------------------------'
+                       .flatten.sort.each { |name| MultiLogger.info(name) }
+        MultiLogger.info '---------------------------------------------'
       end
 
       def print_device_list
         puts Device.available.map(&:name)
         exit(0)
@@ -72,15 +71,10 @@
       def load_custom_config(config_path = nil)
         return unless config_path
 
         Config.custom_path = config_path
       end
-
-      def debug_mode
-        MultiLogger.instance.debug_mode = true
-        print_version
-      end
     end
 
     def initialize
       @inputs = Plugin::Inputs::Input.plugins.map(&:new)
       @filters = Plugin::Filters::Filter.plugins.map(&:new)
@@ -95,48 +89,56 @@
       @inputs.first.run do |event|
         filtered = filter(event)
         parsed = parse(filtered)
         buffered = buffer(parsed)
         detected = detect(buffered)
-        execute(detected)
+        merged = merge(detected)
+        execute(merged)
       end
     end
 
     def filter(event)
-      @filters.reduce(event) { |e, f| f.filter(e) if e }
+      event if @filters.any? { |f| f.filter(event) }
     end
 
     def parse(event)
-      @parsers.reduce(event) { |e, p| p.parse(e) if e  }
+      @parsers.reduce(event) { |e, p| p.parse(e) if e }
     end
 
     def buffer(event)
       @buffers.each { |b| b.buffer(event) }
     end
 
     # @param buffers [Array<Buffer>]
-    # @return [Event] if event is detected
-    # @return [NilClass] if event is NOT detected
+    # @return [Array<Event>]
     def detect(buffers)
-      @detectors.each_with_object([]) do |detector, index_records|
-        event = detector.detect(buffers) # event
-
-        if event&.record&.mergable?
-          event.record.merge(records: index_records)
-          buffers.each(&:clear) # clear buffer
-          break(event)
+      @detectors.reduce([]) do |detected, detector|
+        if (event = detector.detect(buffers))
+          detected << event
+        else
+          detected
         end
-
-        break nil if @detectors.last == detector
       end
     end
 
+    # @param events [Array<Event>]
+    # @return [Event] a Event merged all records from arguments
+    # @return [NilClass] when event is NOT given
+    def merge(events)
+      main_events, modifiers = events.partition { |event| event.record.mergable? }
+      return nil unless (main_event = main_events.first)
+
+      main_event.record.merge(records: modifiers.map(&:record))
+      main_event
+    end
+
     def execute(event)
       return unless event
 
       executor = @executors.find do |e|
         e.executable?(event)
       end
+
       executor&.execute(event)
     end
   end
 end