terminal_rb 0.14.0 → 0.16.0

data/lib/terminal/input/key_event.rb

@@ -2,9 +2,85 @@
 
 module Terminal
   #
-  # Key event reported from {read_key_event}.
+  # Key event reported from {read_key_event} and {on_key_event}.
   #
   class KeyEvent
+    # ANSI code sequence received from standard input.
+    # This can be a simple value like `"a"`or more complex input like
+    # `"\e[24;6~"` (for Shift+Ctrl+F12).
+    #
+    # @return [String] received ANSI code sequence
+    attr_reader :raw
+
+    # Pressed key without any modifiers.
+    # This can be a string for simple keys like `"a"` or a Symbol like `:F12`
+    # (see {.key_names}).
+    # @return [String, Symbol] key without modifiers
+    attr_reader :key
+
+    # Modifier key code. This represents the encoded key modifier like `Shift`
+    # or `Alt`.
+    #
+    # @return [Integer] modifier key code
+    attr_reader :modifier
+
+    # Mouse event position.
+    #
+    # @return [[Integer,Integer]] row and column
+    # @return nil when no coordinates are assigned
+    attr_reader :position
+
+    # Name of the key event.
+    # This can be a simple name like `"a"` or `"Shift+Ctrl+F12"` for combined
+    # keys.
+    #
+    # @return [String] key name
+    attr_reader :name
+
+    # @attribute [r] modifier?
+    # @return [true, false] whether a key modifier was pressed
+    def modifier? = @modifier != 0
+
+    # @attribute [r] simple?
+    # @return [true, false] whether a simple key was pressed
+    def simple? = @raw == @name
+
+    # All pressed keys.
+    # This is composed by all {modifier} and the {key}.
+    #
+    # @return [Array<Symbol, String>] all pressed keys
+    def to_a = @ary.dup
+
+    # @private
+    def to_ary = simple? ? [@raw] : [@raw, @name]
+
+    # @private
+    def to_s = @name.dup
+
+    # @private
+    def inspect = "<#{self.class.name} #{to_ary.map(&:inspect).join(' ')}>"
+
+    # @private
+    def freeze
+      @raw.freeze
+      @key.freeze
+      @position.freeze
+      @name.freeze
+      super
+    end
+
+    private
+
+    def initialize(raw, key, modifier, position)
+      @raw = raw
+      @key = key
+      @modifier = modifier
+      @position = position
+      @ary = MODIFIERS.filter_map { |b, n| n if modifier.allbits?(b) }
+      @ary << key if key
+      @name = @ary.join('+') # .encode(Encoding::UTF_8)
+    end
+
     class << self
       # @attribute [w] caching
       # @return [true, false] whether {KeyEvent}s should be cached
@@ -12,24 +88,33 @@ module Terminal
 
       # @attribute [w] caching
       def caching=(value)
-        if value
-          @cache ||= {}
-        else
-          @cache = nil
-        end
+        value ? @cache ||= {} : @cache = nil
       end
 
-      # Translate a keyboard input string into a related KeyEvent
+      # @attribute [r] key_names
+      # @return [Array<Symbol>] list of all avilable key names (see {key})
+      def key_names
+        (
+          @names ||=
+            (@csiu.values + @csi.values + @ss3.values)
+              .uniq
+              .keep_if { Symbol === _1 }
+              .sort!
+        ).dup
+      end
+
+      # Translate a ANSI input code sequence into a related KeyEvent.
       #
       # @param raw [String] keyboard input
       # @return [KeyEvent] related key event
       def [](raw)
+        cached = @cache[raw] and return cached if @cache
         return new(raw, *@single_key[raw.ord]) if raw.size == 1
         return unknown(raw) if raw[0] != "\e"
         return esc1(raw, raw[1]) if raw.size == 2 # ESC ?
         case raw[1]
-        when "\e" # ESC ESC ...
-          return esc_esc(raw)
+        when "\e"
+          return esc_esc(raw) # ESC ESC ...
         when 'O'
           return new(raw, *@ss3[raw[2].ord]) if raw.size == 3 # ESC O ?
         when '['
@@ -37,15 +122,17 @@ module Terminal
           if raw.size == 6 && raw[2] == 'M' # ESC [ M b c r
             return mouse_vt200(raw)
           end
-          return csi1(raw) if raw.start_with?("\e[1;") # ESC [ 1 ; ...
+          if raw.size > 4 && raw[2] == '1' && raw[3] == ';'
+            return csi(raw) # ESC [ 1 ; ...
+          end
           case raw[-1]
-          when '~' # ESC [ ... ~
-            return legacy(raw)
-          when 'u' # ESC [ ... u
-            return csi_u(raw)
-          when 'M' # ESC [ ... M
-            return raw[2] == '<' ? mouse_sgr(raw) : mouse_urxvt(raw)
-          when 'm' # ESC [ ... m
+          when '~'
+            return legacy(raw) # ESC [ ... ~
+          when 'u'
+            return csi_u(raw) # ESC [ ... u
+          when 'M', 'm'
+            # ESC [ ... M
+            # ESC [ ... m
             return mouse_sgr(raw) if raw[2] == '<'
           end
         end
@@ -53,40 +140,29 @@ module Terminal
       end
 
       # @private
-      def new(raw, key = raw, modifier = 0, extra = nil)
-        @cache ? (@cache[raw] ||= super.freeze) : super.freeze
+      def new(raw, key = raw, modifier = 0, position = nil)
+        (@cache && position.nil? ? @cache[raw] ||= super : super).freeze
       end
 
       private
 
       def unknown(raw) = new(raw, nil)
 
-      def csi_u(raw)
-        # ESC [ <code> u
-        # ESC [ <code> ; <modifier> u
-        return unknown(raw) if raw.size < 4
-        idx = raw.index(';')
-        code = raw[2..(idx ? idx - 1 : -2)].to_i
-        new(
-          raw,
-          @csiu[code] || code.chr(Encoding::UTF_8),
-          idx ? [raw[(idx + 1)..-2].to_i - 1, 0].max : 0
-        )
+      def esc1(raw, char)
+        # ESC ?
+        key, modifier = @esc1[char.ord]
+        new(raw, key || char, modifier || 2)
       end
 
-      def legacy(raw)
-        # ESC [ <code> ~
-        # ESC [ <code> ; <modifier> ~
-        return unknown(raw) if raw.size < 4
-        idx = raw.index(';')
-        new(
-          raw,
-          @csi[raw[2..(idx ? idx - 1 : -2)].to_i],
-          idx ? [raw[(idx + 1)..-2].to_i - 1, 0].max : 0
-        )
+      def esc_esc(raw)
+        # ESC ESC ?
+        # ESC ESC ...
+        return esc1(raw, raw[2]) if raw.size == 3
+        ret = self[raw[1..]]
+        new(raw, ret.key, ret.modifier | 2)
       end
 
-      def csi1(raw)
+      def csi(raw)
         # ESC [ 1 ; [~ABCDEFHPQRS]
         # ESC [ 1 ; <modifier> [~ABCDEFHPQRS]
         return unknown(raw) if raw.size < 5
@@ -97,19 +173,33 @@ module Terminal
         new(raw, key, modifier)
       end
 
-      def esc_esc(raw)
-        return esc1(raw, raw[2]) if raw.size == 3 # ESC ESC ?
-        ret = self[raw[1..]]
-        new(raw, ret.key, ret.modifier | 2) # ESC ESC ...
+      def legacy(raw)
+        # ESC [ <code> ~
+        # ESC [ <code> ; <modifier> ~
+        return unknown(raw) if raw.size < 4
+        idx = raw.index(';')
+        new(
+          raw,
+          @csi[raw[2..(idx ? idx - 1 : -2)].to_i],
+          idx ? [raw[(idx + 1)..-2].to_i - 1, 0].max : 0
+        )
       end
 
-      def esc1(raw, char)
-        key, modifier = @esc1[char.ord]
-        new(raw, key || char, modifier || 2)
+      def csi_u(raw)
+        # ESC [ <code> u
+        # ESC [ <code> ; <modifier> u
+        return unknown(raw) if raw.size < 4
+        idx = raw.index(';')
+        code = raw[2..(idx ? idx - 1 : -2)].to_i
+        new(
+          raw,
+          @csiu[code] || code.chr(Encoding::UTF_8),
+          idx ? [raw[(idx + 1)..-2].to_i - 1, 0].max : 0
+        )
       end
 
       def mouse_vt200(raw)
-        # ESC [ M b c r
+        # ESC [ M <btn> <col> <row>
         mouse_event(raw, *raw[3..].chars.map! { _1.ord - 32 })
       end
 
@@ -118,117 +208,40 @@ module Terminal
         # ESC [ < <code> ; <col> ; <row> m
         return unknown(raw) if raw.size < 8
         bcr = raw[3..-2].split(';', 3).map!(&:to_i)
-        bcr.size == 3 ? mouse_event(raw, *bcr) : unknown(raw)
+        bcr.size == 3 ? mouse_event(raw, *bcr, raw[-1] == 'm') : unknown(raw)
       end
 
-      def mouse_urxvt(raw)
-        # ESC [ <code> ; <col> ; <row> M
-        return unknown(raw) if raw.size < 8
-        bcr = raw[2..-2].split(';', 3).map!(&:to_i)
-        bcr.size == 3 ? mouse_event(raw, *bcr) : unknown(raw)
-      end
+      # def mouse_urxvt(raw)
+      #   # ESC [ <code> ; <col> ; <row> M
+      #   unknown(raw) # currently not supported
+      # end
 
-      def mouse_event(raw, btn, col, row)
+      def mouse_event(raw, btn, col, row, up = false)
         return unknown(raw) if btn < 0 || col < 1 || row < 1
-        key, btn = kind_of_mouse_event(btn)
+        key = (btn & 1).nonzero? ? 1 : 0
+        key += 2 if btn.allbits?(2)
         modifier = btn.allbits?(4) ? 1 : 0
         modifier += 2 if btn.allbits?(8)
         modifier += 4 if btn.allbits?(16)
-        new(raw, key, modifier, [col, row])
+        modifier += 256 if moved = btn.allbits?(32)
+        key += 4 if btn.allbits?(64)
+        key += 8 if btn.allbits?(128)
+        new(raw, mouse_name(key, up, moved), modifier, [row, col])
       end
 
-      def mouse_event_key(btn)
-        kind = btn & 3
-        key = (btn >= 64 ? @mouse_wheel_kind : @mouse_kind)[kind]
-        # TODO: what about btn >= 128 for more mouse wheel events?
-        [btn - kind, key]
+      def mouse_name(key, up, moved)
+        return up ? :MBLeftUp : :MBLeft if key == 0
+        return up ? :MBMiddleUp : :MBMiddle if key == 1
+        return up ? :MBRightUp : :MBRight if key == 2
+        return moved ? :Mouse : :MBUp if key == 3
+        return :MWUp if key == 4
+        return :MWDown if key == 5
+        return :MWLeft if key == 6
+        return :MWRight if key == 7
+        :"MB_#{key - 8}#{'Up' if up}"
       end
     end
 
-    # Event string received from standard input.
-    # This can be a simple value like `"a"`or more complex input like
-    # `"\e[24;6~"` (for Shift+Ctrl+F12).
-    #
-    # @return [String] received event string
-    attr_reader :raw
-
-    # Pressed key without any modifiers.
-    # This can be a string for simple keys like `"a"` or a Symbol like `:F12`.
-    # @return [String, Symbol] key without modifiers
-    attr_reader :key
-
-    # Modifier key code. This represents the encoded key modifier like `Shift`
-    # or `Alt`.
-    #
-    # @return [Integer] modifier key code
-    attr_reader :modifier
-
-    # @comment for mouse events
-    # @private
-    attr_reader :extra
-
-    # Name of the key event.
-    # This can be a simple name like `"a"` or `"Shift+Ctrl+F12"` for combined
-    # keys.
-    #
-    # @return [String] key name
-    attr_reader :name
-
-    # @attribute [r] modifier?
-    # @return [true, false] whether a key modifier was pressed
-    def modifier? = @modifier != 0
-
-    # @attribute [r] simple?
-    # @return [true, false] whether a simple key was pressed
-    def simple? = @raw == @name
-
-    # All pressed keys.
-    # This is composed by all {modifier} and the {key}.
-    #
-    # @return [Array<Symbol, String>] all pressed keys
-    def to_a = @ary.dup
-
-    # @private
-    def to_ary = simple? ? [@raw] : [@raw, @name]
-
-    # @private
-    def to_s = @name.dup
-
-    # @private
-    def inspect = "<#{self.class.name} #{to_ary.map(&:inspect).join(' ')}>"
-
-    # @private
-    def freeze
-      @raw.freeze
-      @key.freeze
-      @extra.freeze
-      @name.freeze
-      super
-    end
-
-    private
-
-    def initialize(raw, key, modifier, extra)
-      @raw = raw
-      @key = key
-      @modifier = modifier
-      @extra = extra
-      @ary = MODIFIERS.filter_map { |b, n| n if modifier.allbits?(b) }
-      @ary << key if key
-      @name = @ary.join('+') # .encode(Encoding::UTF_8)
-    end
-
-    @mouse_kind = %i[
-      MButton1
-      MButton2
-      MButton3
-      MButtonUp
-      MButton4
-      MButton5
-    ].freeze
-
-    @mouse_wheel_kind = %i[MWheelDown MWheelUp MWheelRight MWheelLeft].freeze
-
     @csiu = {
       0x02 => :Ins,
       0x09 => :Tab,
@@ -357,6 +370,8 @@ module Terminal
       0x44 => :Left, # D
       0x46 => :End, # F
       0x48 => :Home, # H
+      0x49 => :Focus, # I
+      0x4f => :UnFocus, # O
       0x50 => :F1, # P
       0x51 => :F2, # Q
       0x52 => :F3, # R
@@ -421,7 +436,8 @@ module Terminal
       16 => :Hyper,
       32 => :Meta,
       64 => :Caps,
-      128 => :Num
+      128 => :Num,
+      256 => :Move # mouse
     }.freeze
     private_constant :MODIFIERS
   end

data/lib/terminal/input.rb

@@ -16,7 +16,7 @@ module Terminal
     # @return [:dumb]
     #   for non-interactive input (pipes etc.)
     # @return [:error]
-    #   when input device is closed
+    #   when input device is not avail (closed)
     def input_mode
       @input_mode ||= find_input_mode
     end
@@ -34,6 +34,10 @@ module Terminal
     # @return [[String, String]] key code and key name in `:both` mode
     # @return [nil] in error case
     def read_key(mode: :named)
+      warn(
+        'Terminal.read_key is deprecaded; use Terminal.read_key_event instead.',
+        uplevel: 1
+      )
       event = read_key_event or return
       return event.raw if mode == :raw
       key, name = event
@@ -48,25 +52,109 @@ module Terminal
       case input_mode
       when :dumb
         raw = read_dumb or return
-        opts = DUMB_KEYS[raw.ord] if raw.size == 1
+        opts = @dumb_keys[raw.ord] if raw.size == 1
         KeyEvent.new(raw, *opts)
       when :csi_u, :legacy
-        # raw = with_mouse ? read_tty_with_mouse : read_tty
-        KeyEvent[raw] if (raw = read_tty)
+        raw = read_tty or return
+        KeyEvent[raw]
+      end
+    end
+
+    # Event loop for key and mouse events.
+    #
+    # @param mouse [true, false]
+    #   whether mouse buttons should be reported
+    # @param mouse_move [true, false]
+    #   whether mouse movement should be reported
+    # @param focus [true, false]
+    #   whether focus/unfocus of terminal window should be reported
+    # @yieldparam event [KeyEvent]
+    #   next event
+    # @yieldreturn [true, false]
+    #   whether the loop should be continued
+    # @return [true]
+    #   when the loop was started
+    # @return [false]
+    #   when the current input device is not available
+    # @return [nil]
+    #   when no block was given
+    def on_key_event(mouse: false, mouse_move: false, focus: false, &block)
+      return unless block
+      case input_mode
+      when :dumb
+        on_bumb_key_event(&block)
+        true
+      when :csi_u, :legacy
+        on_tty_key_event(mouse, mouse_move, focus, &block)
+        true
+      else
+        false
       end
     end
 
     private
 
+    def on_tty_key_event(mouse, mouse_move, focus)
+      # highlight: '1001'
+      # drag: '1002'
+      # move: '1003'
+      # focus: '1004' - lost: "\e[O", get: "\e[I"
+      # ext: '1005'
+      # sgr: '1006'
+      # urxvt: '1015'
+      # pixel: '1016'
+      opts =
+        if mouse || mouse_move || focus
+          opts = mouse ? +"\e[?1006;1000" : +"\e[?1006"
+          opts << ';1003' if mouse_move
+          opts << ';1004' if focus
+          raw_write("#{opts}h") ? "#{opts}l" : nil
+        end
+      STDIN.noecho do |stdin|
+        while (raw = stdin.getch)
+          if raw != "\e"
+            yield(KeyEvent[raw]) ? next : break
+          end
+          lesci = 0
+          while (nc = stdin.read_nonblock(1, exception: false))
+            break unless String === nc
+            lesci = raw.size if nc == "\e"
+            raw << nc
+          end
+          if lesci < 2
+            yield(KeyEvent[raw]) ? next : break
+          end
+          break unless raw[1..].split("\e").all? { yield(KeyEvent["\e#{_1}"]) }
+        end
+      end
+    rescue Interrupt
+      # nop
+    rescue IOError, SystemCallError
+      @input_mode = :error
+    ensure
+      raw_write(opts) if opts
+    end
+
+    def on_bumb_key_event
+      while (raw = read_dumb)
+        opts = @dumb_keys[raw.ord] if raw.size == 1
+        return unless yield(KeyEvent.new(raw, *opts))
+      end
+    end
+
     def find_input_mode
-      # order is important!
       im = ENV['INPUT_MODE']
-      return :dumb if im == 'dumb'
       return :legacy if im == 'legacy'
-      return :dumb unless STDIN.tty?
-      if ansi? && raw_write("\e[>1u\e[?u\e[c") && csi_u?
-        at_exit { raw_write("\e[<u") }
-        return :csi_u
+      return :dumb if im == 'dumb' || !STDIN.tty?
+      STDIN.noecho do |stdin|
+        if raw_write("\e[>1u\e[?u\e[c")
+          inp = +''
+          inp << stdin.getch until inp.rindex('c')
+          if inp.include?("\e[?1u")
+            at_exit { raw_write("\e[<u") }
+            return :csi_u
+          end
+        end
       end
       :legacy
     rescue Interrupt
@@ -75,12 +163,6 @@ module Terminal
       :error
     end
 
-    def csi_u?
-      inp = +''
-      STDIN.raw { inp << _1.getch until inp.rindex('c') }
-      inp.include?("\e[?1u")
-    end
-
     def read_dumb
       STDIN.getc
     rescue Interrupt
@@ -90,45 +172,31 @@ module Terminal
       nil
     end
 
-    def read_tty_with_mouse(each_move: false)
-      # highlight: '1001'
-      # drag: '1002'
-      # move: '1003'
-      # ext: '1005'
-      # sgr: '1006'
-      # urxvt: '1015'
-      # pixel: '1016'
-      opts = each_move ? '1000;1003;1006;1015' : '1000;1006;1015'
-      opts = raw_write("\e[?#{opts}h") ? "\e[?#{opts}l" : nil
-      read_tty
-    ensure
-      raw_write(opts) if opts
-    end
-
     def read_tty
-      if (key = STDIN.getch) == "\e"
-        while (nc = STDIN.read_nonblock(1, exception: false))
-          String === nc ? key << nc : break
+      STDIN.noecho do |stdin|
+        if (key = stdin.getch) == "\e"
+          while (nc = stdin.read_nonblock(1, exception: false))
+            String === nc ? key << nc : break
+          end
         end
+        key
       end
-      key
     rescue Interrupt
       nil
     rescue IOError, SystemCallError
       @input_mode = :error
       nil
     end
-
-    DUMB_KEYS = {
-      0x05 => ['c', 4],
-      0x08 => :Back,
-      0x09 => :Tab,
-      0x0a => :Enter,
-      0x0d => :Return,
-      0x1b => :Esc
-    }.compare_by_identity.freeze
-    private_constant :DUMB_KEYS
   end
 
+  @dumb_keys = {
+    0x05 => ['c', 4],
+    0x08 => :Back,
+    0x09 => :Tab,
+    0x0a => :Enter,
+    0x0d => :Return,
+    0x1b => :Esc
+  }.compare_by_identity.freeze
+
   autoload :KeyEvent, "#{__dir__}/input/key_event.rb"
 end

data/lib/terminal/shell.rb

@@ -116,12 +116,8 @@ module Terminal
         end
 
         def initialize(enum)
-          @enum =
-            if enum.respond_to?(:enum_for)
-              enum.enum_for(:each)
-            else
-              Enumerator.new { |y| enum.each { y << _1 } }
-            end
+          return @enum = enum.enum_for(:each) if enum.respond_to?(:enum_for)
+          @enum = Enumerator.new { |y| enum.each { y << _1 } }
         end
       end
     end