fusuma 2.0.0.pre → 2.0.3

data/lib/fusuma/plugin/detectors/swipe_detector.rb

@@ -1,48 +1,103 @@
 # frozen_string_literal: true
 
-require_relative './detector.rb'
+require_relative './detector'
 
 module Fusuma
   module Plugin
     module Detectors
       class SwipeDetector < Detector
+        SOURCES = ['gesture'].freeze
         BUFFER_TYPE = 'gesture'
         GESTURE_RECORD_TYPE = 'swipe'
 
         FINGERS = [3, 4].freeze
-        BASE_THERESHOLD = 10
-        BASE_INTERVAL = 0.5
+        BASE_THERESHOLD = 25
 
         # @param buffers [Array<Buffers::Buffer>]
-        # @return [Event] if event is detected
+        # @return [Events::Event] if event is detected
         # @return [NilClass] if event is NOT detected
         def detect(buffers)
-          buffer = buffers.find { |b| b.type == BUFFER_TYPE }
-                          .select_by_events { |e| e.record.gesture == GESTURE_RECORD_TYPE }
-
-          return if buffer.empty?
-
-          move_x = buffer.avg_attrs(:move_x)
-          move_y = buffer.avg_attrs(:move_y)
-
-          finger = buffer.finger
-          direction = Direction.new(move_x: move_x.to_f, move_y: move_y.to_f).to_s
-          quantity = Quantity.new(move_x: move_x.to_f, move_y: move_y.to_f).to_f
-
-          index = create_index(gesture: type,
-                               finger: finger,
-                               direction: direction)
-
-          return unless enough?(index: index, quantity: quantity)
+          gesture_buffer = buffers.find { |b| b.type == BUFFER_TYPE }
+                                  .select_from_last_begin
+                                  .select_by_events { |e| e.record.gesture == GESTURE_RECORD_TYPE }
+
+          updating_events = gesture_buffer.updating_events
+          return if updating_events.empty?
+
+          updating_time = 100 * (updating_events.last.time - updating_events.first.time)
+          oneshot_move_x = gesture_buffer.sum_attrs(:move_x) / updating_time
+          oneshot_move_y = gesture_buffer.sum_attrs(:move_y) / updating_time
+
+          finger = gesture_buffer.finger
+          status = case gesture_buffer.events.last.record.status
+                   when 'end'
+                     'end'
+                   when 'update'
+                     if updating_events.length == 1
+                       'begin'
+                     else
+                       'update'
+                     end
+                   else
+                     gesture_buffer.events.last.record.status
+                   end
+
+          delta = if status == 'end'
+                    gesture_buffer.events[-2].record.delta
+                  else
+                    gesture_buffer.events.last.record.delta
+                  end
+
+          repeat_direction = Direction.new(move_x: delta.move_x, move_y: delta.move_y).to_s
+          repeat_quantity = Quantity.new(move_x: delta.move_x, move_y: delta.move_y).to_f
+
+          repeat_index = create_repeat_index(gesture: type, finger: finger,
+                                             direction: repeat_direction, status: status)
+
+          if status == 'update'
+            return unless moved?(repeat_quantity)
+
+            oneshot_direction = Direction.new(move_x: oneshot_move_x, move_y: oneshot_move_y).to_s
+            oneshot_quantity = Quantity.new(move_x: oneshot_move_x, move_y: oneshot_move_y).to_f
+            oneshot_index = create_oneshot_index(gesture: type, finger: finger,
+                                                 direction: oneshot_direction)
+            if enough_oneshot_threshold?(index: oneshot_index, quantity: oneshot_quantity)
+              return [
+                create_event(record: Events::Records::IndexRecord.new(
+                  index: oneshot_index, trigger: :oneshot, args: delta.to_h
+                )),
+                create_event(record: Events::Records::IndexRecord.new(
+                  index: repeat_index, trigger: :repeat, args: delta.to_h
+                ))
+              ]
+            end
+          end
+          create_event(record: Events::Records::IndexRecord.new(
+            index: repeat_index, trigger: :repeat, args: delta.to_h
+          ))
+        end
 
-          create_event(record: Events::Records::IndexRecord.new(index: index))
+        # @param [String] gesture
+        # @param [Integer] finger
+        # @param [String] direction
+        # @param [String] status
+        # @return [Config::Index]
+        def create_repeat_index(gesture:, finger:, direction:, status:)
+          Config::Index.new(
+            [
+              Config::Index::Key.new(gesture),
+              Config::Index::Key.new(finger.to_i),
+              Config::Index::Key.new(direction, skippable: true),
+              Config::Index::Key.new(status)
+            ]
+          )
         end
 
         # @param [String] gesture
         # @param [Integer] finger
         # @param [String] direction
         # @return [Config::Index]
-        def create_index(gesture:, finger:, direction:)
+        def create_oneshot_index(gesture:, finger:, direction:)
           Config::Index.new(
             [
               Config::Index::Key.new(gesture),
@@ -54,41 +109,23 @@ module Fusuma
 
         private
 
-        def enough?(index:, quantity:)
-          enough_interval?(index: index) && enough_distance?(index: index, quantity: quantity)
+        def moved?(repeat_quantity)
+          repeat_quantity > 0.3
         end
 
-        def enough_distance?(index:, quantity:)
+        def enough_oneshot_threshold?(index:, quantity:)
           quantity > threshold(index: index)
         end
 
-        def enough_interval?(index:)
-          return true if first_time?
-          return true if (Time.now - last_time) > interval_time(index: index)
-
-          false
-        end
-
         def threshold(index:)
           @threshold ||= {}
           @threshold[index.cache_key] ||= begin
-                           keys_specific = Config::Index.new [*index.keys, 'threshold']
-                           keys_global = Config::Index.new ['threshold', type]
-                           config_value = Config.search(keys_specific) ||
-                                          Config.search(keys_global) || 1
-                           BASE_THERESHOLD * config_value
-                         end
-        end
-
-        def interval_time(index:)
-          @interval_time ||= {}
-          @interval_time[index.cache_key] ||= begin
-              keys_specific = Config::Index.new [*index.keys, 'interval']
-              keys_global = Config::Index.new ['interval', type]
-              config_value = Config.search(keys_specific) ||
-                             Config.search(keys_global) || 1
-              BASE_INTERVAL * config_value
-            end
+            keys_specific = Config::Index.new [*index.keys, 'threshold']
+            keys_global = Config::Index.new ['threshold', type]
+            config_value = Config.search(keys_specific) ||
+                           Config.search(keys_global) || 1
+            BASE_THERESHOLD * config_value
+          end
         end
 
         # direction of gesture
@@ -99,8 +136,8 @@ module Fusuma
           UP = 'up'
 
           def initialize(move_x:, move_y:)
-            @move_x = move_x
-            @move_y = move_y
+            @move_x = move_x.to_f
+            @move_y = move_y.to_f
           end
 
           def to_s
@@ -109,8 +146,8 @@ module Fusuma
 
           def calc
             if @move_x.abs > @move_y.abs
-              @move_x > 0 ? RIGHT : LEFT
-            elsif @move_y > 0
+              @move_x.positive? ? RIGHT : LEFT
+            elsif @move_y.positive?
               DOWN
             else
               UP
@@ -121,8 +158,8 @@ module Fusuma
         # quantity of gesture
         class Quantity
           def initialize(move_x:, move_y:)
-            @x = move_x.abs
-            @y = move_y.abs
+            @x = move_x.to_f.abs
+            @y = move_y.to_f.abs
           end
 
           def to_f

data/lib/fusuma/plugin/events/event.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require_relative '../base.rb'
-require_relative './records/record.rb'
-require_relative './records/text_record.rb'
+require_relative '../base'
+require_relative './records/record'
+require_relative './records/text_record'
 
 module Fusuma
   module Plugin
@@ -15,7 +15,8 @@ module Fusuma
         # @param time [Time]
         # @param tag [Tag]
         # @param record [String, Record]
-        def initialize(time: Time.now, tag:, record:)
+        def initialize(tag:, record:, time: Time.now)
+          super()
           @time = time
           @tag = tag
           @record = case record

data/lib/fusuma/plugin/events/records/context_record.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Fusuma
+  module Plugin
+    module Events
+      module Records
+        # Context Record
+        class ContextRecord < Record
+          # define gesture format
+          attr_reader :name, :value
+
+          # @param name [#to_sym]
+          # @param value [String]
+          def initialize(name:, value:)
+            super()
+            @name = name.to_sym
+            @value = value
+          end
+
+          def type
+            :context
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fusuma/plugin/events/records/gesture_record.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative './text_record.rb'
+require_relative './text_record'
 
 module Fusuma
   module Plugin
@@ -9,19 +9,22 @@ module Fusuma
         # Gesture Record
         class GestureRecord < Record
           # define gesture format
-          attr_reader :status, :gesture, :finger, :direction
+          attr_reader :status, :gesture, :finger, :delta
 
-          Delta = Struct.new(:move_x, :move_y, :zoom, :rotate)
+          Delta = Struct.new(:move_x, :move_y,
+                             :unaccelerated_x, :unaccelerated_y,
+                             :zoom, :rotate)
 
           # @param status [String]
           # @param gesture [String]
           # @param finger [String, Integer]
-          # @param direction [Delta, NilClass]
-          def initialize(status:, gesture:, finger:, direction:)
+          # @param delta [Delta, NilClass]
+          def initialize(status:, gesture:, finger:, delta:)
+            super()
             @status  = status
             @gesture = gesture
             @finger  = finger.to_i
-            @direction = direction
+            @delta = delta
           end
         end
       end

data/lib/fusuma/plugin/events/records/index_record.rb

@@ -8,36 +8,68 @@ module Fusuma
         # have index
         class IndexRecord < Record
           # define gesture format
-          attr_reader :index
-          attr_reader :position
+          attr_accessor :index
+          attr_reader :position, :trigger, :args
 
           # @param [Config::Index] index
           # @param [Symbol] position [:prefix, :body, :surfix]
-          def initialize(index:, position: :body)
+          # @param [Symbol] trigger [:oneshot, :repeat]
+          def initialize(index:, position: :body, trigger: :oneshot, args: {})
+            super()
             @index = index
             @position = position
+            @trigger = trigger
+            @args = args
           end
 
           def type
             :index
           end
 
+          # FIXME: move to Config::Index
           # @param records [Array<IndexRecord>]
-          # @return [IndexRecord]
-          def merge(records:)
+          # @return [IndexRecord] when merge is succeeded
+          # @return [NilClass] when merge is not succeeded
+          def merge(records:, index: @index)
+            # FIXME: cache
             raise "position is NOT body: #{self}" unless mergable?
 
-            @index = records.reduce(@index) do |merged_index, record|
-              case record.position
-              when :prefix
-                Config::Index.new([*record.index.keys, *merged_index.keys])
-              when :surfix
-                Config::Index.new([*merged_index.keys, *record.index.keys])
-              else
-                raise "invalid index position: #{record}"
+            if records.empty?
+              if Config.find_execute_key(index)
+                @index = index
+                return self
               end
+              return nil
+            end
+
+            record = records.shift
+            new_index = case record.position
+                        when :surfix
+                          Config::Index.new([*index.keys, *record.index.keys])
+                        else
+                          raise "invalid index position: #{record}"
+                        end
+
+            return unless exist_on_conf?(new_index)
+
+            merge(records: records, index: new_index)
+          end
+
+          # @param [Config::Searcher] searcher
+          def exist_on_conf?(index = @index)
+            Config.search(index)
+          end
+
+          # @return [Integer]
+          def trigger_priority
+            case @trigger
+            when :oneshot
+              10
+            when :repeat
+              100
+            else
+              1000
             end
-            self
           end
 
           def mergable?

data/lib/fusuma/plugin/events/records/record.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative '../../base.rb'
+require_relative '../../base'
 
 module Fusuma
   module Plugin

data/lib/fusuma/plugin/events/records/text_record.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative './record.rb'
+require_relative './record'
 
 module Fusuma
   module Plugin
@@ -10,6 +10,7 @@ module Fusuma
         class TextRecord < Record
           # @param text [String]
           def initialize(text)
+            super()
             @text = text
           end
 

data/lib/fusuma/plugin/executors/command_executor.rb

@@ -1,20 +1,30 @@
 # frozen_string_literal: true
 
-require 'posix/spawn'
-require_relative './executor.rb'
+require_relative './executor'
 
 module Fusuma
   module Plugin
     module Executors
       # Exector plugin
       class CommandExecutor < Executor
+        # Executor parameter on config.yml
+        # @return [Array<Symbol>]
+        def execute_keys
+          [:command]
+        end
+
         def execute(event)
           search_command(event).tap do |command|
             break unless command
 
-            MultiLogger.info(command: command)
+            MultiLogger.info(command: command, args: event.record.args)
+
+            accel = args_accel(event)
+            additional_env = event.record.args
+                                  .deep_transform_keys(&:to_s)
+                                  .deep_transform_values { |v| (v * accel).to_s }
 
-            pid = POSIX::Spawn.spawn(command.to_s)
+            pid = Process.spawn(additional_env, command.to_s)
             Process.detach(pid)
           end
         end
@@ -31,6 +41,13 @@ module Fusuma
           command_index = Config::Index.new([*event.record.index.keys, :command])
           Config.search(command_index)
         end
+
+        # @param event [Event]
+        # @return [Float]
+        def args_accel(event)
+          accel_index = Config::Index.new([*event.record.index.keys, :accel])
+          (Config.search(accel_index) || 1).to_f
+        end
       end
     end
   end