terminal_rb 0.9.1 → 0.9.4

data/lib/terminal/text.rb

@@ -41,6 +41,10 @@ module Terminal
 
       # Iterate each line of given text.
       #
+      # @example Generate word-by-word wrapped text for a limited output width
+      #   Terminal::Text.each_line('This is a simple test 😀', limit: 6).to_a
+      #   # => ["This", "is a", "simple", "test", "😀"]
+      #
       # @param [#to_s, ...] text
       #   text objects to process
       # @param [#to_i, nil] limit
@@ -66,12 +70,12 @@ module Terminal
         if limit
           limit = limit.to_i
           raise(ArgumentError, "invalid limit - #{limit}") if limit < 1
-          if block_given?
-            lines_in(text, bbcode, ansi, ignore_newline, limit, &block)
+          if block
+            lim_lines(text, bbcode, ansi, ignore_newline, limit, &block)
           else
-            to_enum(:lines_in, text, bbcode, ansi, ignore_newline, limit)
+            to_enum(:lim_lines, text, bbcode, ansi, ignore_newline, limit)
           end
-        elsif block_given?
+        elsif block
           lines(text, bbcode, ansi, ignore_newline, &block)
         else
           to_enum(:lines, text, bbcode, ansi, ignore_newline)
@@ -81,6 +85,10 @@ module Terminal
 
       # Iterate each line and it's display width of given text.
       #
+      # @example Generate word-by-word wrapped text for a limited output width
+      #   Terminal::Text.each_line_with_size('This is a simple test 😀', limit: 6).to_a
+      #   # => [["This", 4], ["is a", 4], ["simple", 6], ["test", 4], ["😀", 2]]
+      #
       # @param (see each_line)
       # @yield [String, Integer] text line and it's display width
       # @return (see each_line)
@@ -96,12 +104,12 @@ module Terminal
         if limit
           limit = limit.to_i
           raise(ArgumentError, "invalid limit - #{limit}") if limit < 1
-          if block_given?
-            pairs_in(text, bbcode, ansi, ignore_newline, limit, &block)
+          if block
+            lim_pairs(text, bbcode, ansi, ignore_newline, limit, &block)
           else
-            to_enum(:pairs_in, text, bbcode, ansi, ignore_newline, limit)
+            to_enum(:lim_pairs, text, bbcode, ansi, ignore_newline, limit)
           end
-        elsif block_given?
+        elsif block
           pairs(text, bbcode, ansi, ignore_newline, &block)
         else
           to_enum(:pairs, text, bbcode, ansi, ignore_newline)
@@ -122,315 +130,322 @@ module Terminal
         sco == 0xff9e || sco == 0xff9f ? 2 : 1
       end
 
-      def each_part(text, bbcode, ansi, ignore_newline)
-        newline = ignore_newline ? :space : :nl
-        text.each do |txt|
-          txt = bbcode ? Ansi.bbcode(txt) : txt.to_s
-          next yield(:hard_nl) if txt.empty?
-          txt = txt.encode(ENC) if txt.encoding != ENC
-          word = nil
-          txt.scan(SCAN_EXPR) do |nl, csi, osc, space, gc|
-            if gc
-              next word.add(gc, char_width(gc)) if word
-              next word = Word.new(gc, char_width(gc))
-            end
-            yield(word) if word
-            word = nil
-            next yield(:space) if space
-            next yield(newline) if nl
-            next unless ansi
-            next yield(:seq, osc) if osc
-            next yield(:seq_end) if csi == "\e[m" || csi == "\e[0m"
-            yield(:seq, csi)
+      def lim_pairs(text, bbcode, ansi, ignore_newline, limit)
+        line = EMPTY.dup
+        size = 0
+        csi = nil
+        as_snippeds(
+          text,
+          bbcode,
+          ansi,
+          ignore_newline,
+          WordEx
+        ).each do |snipped|
+          if snipped == :space
+            next if size == 0
+            next line << ' ' if (size += 1) <= limit
+            yield(line, size - 1)
+            line = "#{csi}"
+            next size = 0
           end
-          yield(word) if word
-          yield(:hard_nl)
-        end
-        nil
-      end
 
-      def lines(text, bbcode, ansi, ignore_newline)
-        current = EMPTY.dup
-        seq = EMPTY.dup
-        lws = nil
-        each_part(text, bbcode, ansi, ignore_newline) do |part, opt|
-          if part == :space
-            next if lws
-            current << ' '
-            next lws = true
+          if snipped == :nl
+            yield(line, size)
+            line = "#{csi}"
+            next size = 0
           end
 
-          if part.is_a?(Word)
-            current << part
-            next lws = false
+          if snipped == :hard_nl
+            yield(line, size)
+            line = EMPTY.dup
+            csi = nil
+            next size = 0
           end
 
-          if part == :nl
-            yield(lws ? current.chop : current)
-            current = seq.dup
-            next lws = false
+          if snipped == CsiEnd
+            line << CsiEnd if csi
+            next csi = nil
           end
 
-          if part == :hard_nl
-            yield(lws ? current.chop : current)
-            seq.clear
-            current = EMPTY.dup
-            next lws = false
+          next line << (csi = snipped) if snipped.is_a?(Csi)
+          next line << snipped if snipped.is_a?(Osc)
+
+          # Word:
+
+          if (ns = size + snipped.size) <= limit
+            line << snipped
+            next size = ns
           end
 
-          lws = false
+          if line[-1] == ' '
+            line.chop!
+            size -= 1
+          end
+          yield(line, size) if size != 0
 
-          if part == :seq
-            current << opt
-            next seq << opt
+          if snipped.size < limit
+            line = "#{csi}#{snipped}"
+            next size = snipped.size
           end
 
-          # :seq_end
-          current << "\e[m"
-          seq.clear
+          words = snipped.split(limit)
+          if words[-1].size < limit
+            snipped = words.pop
+            line = "#{csi}#{snipped}"
+            size = snipped.size
+          else
+            line = "#{csi}"
+            size = 0
+          end
+          words.each { yield("#{csi}#{_1}", _1.size) }
         end
         nil
       end
 
-      def lines_in(text, bbcode, ansi, ignore_newline, limit)
-        current = EMPTY.dup
-        seq = EMPTY.dup
-        width = 0
-        lws = nil
-        each_part(text, bbcode, ansi, ignore_newline) do |part, opt|
-          if part == :space
-            next if lws
-            if width.succ < limit
-              current << ' '
-              width += 1
-              next lws = true
-            end
-            yield(current)
-            current = seq.dup
-            width = 0
-            next lws = false
+      def lim_lines(text, bbcode, ansi, ignore_newline, limit)
+        line = EMPTY.dup
+        size = 0
+        csi = nil
+        as_snippeds(
+          text,
+          bbcode,
+          ansi,
+          ignore_newline,
+          WordEx
+        ).each do |snipped|
+          if snipped == :space
+            next if size == 0
+            next line << ' ' if (size += 1) <= limit
+            yield(line)
+            line = "#{csi}"
+            next size = 0
           end
 
-          if part.is_a?(Word)
-            if (nw = width + part.size) <= limit
-              current << part
-              width = nw
-              next lws = false
-            end
+          if snipped == :nl
+            yield(line)
+            line = "#{csi}"
+            next size = 0
+          end
 
-            yield(lws ? current.chop : current) if width > 0
-            current = seq.dup
+          if snipped == :hard_nl
+            yield(line)
+            line = EMPTY.dup
+            csi = nil
+            next size = 0
+          end
 
-            if part.size < limit
-              current << part
-              width = part.size
-              next lws = false
-            end
+          if snipped == CsiEnd
+            line << CsiEnd if csi
+            next csi = nil
+          end
 
-            if part.size == limit
-              yield(current + part)
-              current = seq.dup
-              width = 0
-              next lws = false
-            end
+          next line << (csi = snipped) if snipped.is_a?(Csi)
+          next line << snipped if snipped.is_a?(Osc)
 
-            width = 0
-            part.chars.each do |c, w|
-              next current << c if (width += w) <= limit
-              yield(current)
-              current = seq.dup << c
-              width = w
-            end
+          # Word:
 
-            next lws = false
+          if (ns = size + snipped.size) <= limit
+            line << snipped
+            next size = ns
           end
 
-          if part == :nl
-            yield(lws ? current.chop : current)
-            current = seq.dup
-            width = 0
-            next lws = false
+          if line[-1] == ' '
+            line.chop!
+            size -= 1
           end
+          yield(line) if size != 0
 
-          if part == :hard_nl
-            yield(lws ? current.chop : current) if width > 0
-            seq.clear
-            current = EMPTY.dup
-            width = 0
-            next lws = false
+          if snipped.size < limit
+            line = "#{csi}#{snipped}"
+            next size = snipped.size
           end
 
-          lws = false
-
-          if part == :seq
-            current << opt
-            next seq << opt
+          words = snipped.split(limit)
+          if words[-1].size < limit
+            snipped = words.pop
+            line = "#{csi}#{snipped}"
+            size = snipped.size
+          else
+            line = "#{csi}"
+            size = 0
           end
-
-          # :seq_end
-          next if seq.empty?
-          current << "\e[m"
-          seq.clear
+          words.each { yield("#{csi}#{_1}") }
         end
         nil
       end
 
       def pairs(text, bbcode, ansi, ignore_newline)
-        current = EMPTY.dup
-        seq = EMPTY.dup
-        width = 0
-        lws = nil
-        each_part(text, bbcode, ansi, ignore_newline) do |part, opt|
-          if part == :space
-            next if lws
-            current << ' '
-            width += 1
-            next lws = true
+        line = EMPTY.dup
+        size = 0
+        csi = nil
+        as_snippeds(text, bbcode, ansi, ignore_newline, Word).each do |snipped|
+          if snipped == :space
+            next if size == 0
+            line << ' '
+            next size += 1
           end
 
-          if part.is_a?(Word)
-            current << part
-            width += part.size
-            next lws = false
+          if snipped == :nl
+            yield(line, size)
+            line = "#{csi}"
+            next size = 0
           end
 
-          if part == :nl
-            lws ? yield(current.chop, width - 1) : yield(current, width)
-            current = seq.dup
-            width = 0
-            next lws = false
+          if snipped == :hard_nl
+            yield(line, size)
+            line = EMPTY.dup
+            csi = nil
+            next size = 0
           end
 
-          if part == :hard_nl
-            lws ? yield(current.chop, width - 1) : yield(current, width)
-            seq.clear
-            current = EMPTY.dup
-            width = 0
-            next lws = false
+          if snipped == CsiEnd
+            line << CsiEnd if csi
+            next csi = nil
           end
 
-          lws = false
+          next line << (csi = snipped) if snipped.is_a?(Csi)
+          next line << snipped if snipped.is_a?(Osc)
 
-          if part == :seq
-            current << opt
-            next seq << opt
-          end
-
-          # :seq_end
-          next if seq.empty?
-          current << "\e[m"
-          seq.clear
+          # Word:
+          line << snipped
+          size += snipped.size
         end
         nil
       end
 
-      def pairs_in(text, bbcode, ansi, ignore_newline, limit)
-        current = EMPTY.dup
-        seq = EMPTY.dup
-        width = 0
-        lws = nil
-        each_part(text, bbcode, ansi, ignore_newline) do |part, opt|
-          if part == :space
-            next if lws
-            if width.succ < limit
-              current << ' '
-              width += 1
-              next lws = true
-            end
-            yield(current, width)
-            current = seq.dup
-            width = 0
-            next lws = false
+      def lines(text, bbcode, ansi, ignore_newline)
+        line = EMPTY.dup
+        csi = nil
+        as_snippeds(text, bbcode, ansi, ignore_newline, Word).each do |snipped|
+          next line << ' ' if snipped == :space
+
+          if snipped == :nl
+            next if line.empty?
+            yield(line)
+            next line = "#{csi}"
           end
 
-          if part.is_a?(Word)
-            if (nw = width + part.size) <= limit
-              current << part
-              width = nw
-              next lws = false
-            end
+          if snipped == :hard_nl
+            yield(line)
+            line = EMPTY.dup
+            next csi = nil
+          end
 
-            if width > 0
-              lws ? yield(current.chop, width - 1) : yield(current, width)
-            end
-            current = seq.dup
+          if snipped == CsiEnd
+            line << CsiEnd if csi
+            next csi = nil
+          end
 
-            if part.size < limit
-              current << part
-              width = part.size
-              next lws = false
-            end
+          csi = snipped if snipped.is_a?(Csi)
+          # Csi, Osc, Word:
+          line << snipped
+        end
+        nil
+      end
 
-            if part.size == limit
-              yield(current + part, limit)
-              current = seq.dup
-              width = 0
-              next lws = false
+      def as_snippeds(text, bbcode, ansi, ignore_newline, word_class)
+        ret = []
+        last = nil
+        text.each do |txt|
+          if (txt = bbcode ? Ansi.bbcode(txt) : txt.to_s).empty?
+            next ret[-1] = last = :hard_nl if ret[-1] == :space
+            next ret << (last = :hard_nl)
+          end
+          txt = txt.encode(ENC) if txt.encoding != ENC
+          txt.scan(SCAN_EXPR) do |nl, csi, osc, space, gc|
+            if gc
+              next last.add(gc, char_width(gc)) if last.is_a?(word_class)
+              next ret << (last = word_class.new(gc, char_width(gc)))
             end
-
-            width = 0
-            part.chars.each do |c, w|
-              next current << c if (width += w) <= limit
-              yield(current, width - w)
-              current = seq.dup << c
-              width = w
+            next last.is_a?(Symbol) ? nil : ret << (last = :space) if space
+            if nl
+              if ignore_newline
+                next last.is_a?(Symbol) ? nil : ret << (last = :space)
+              end
+              next last == :space ? ret[-1] = last = :nl : ret << (last = :nl)
             end
-
-            next lws = false
+            next unless ansi
+            next ret << (last = Osc.new(osc)) if osc
+            next ret << (last = CsiEnd) if csi == "\e[m" || csi == "\e[0m"
+            last.is_a?(Csi) ? last.add(csi) : ret << (last = Csi.new(csi))
           end
+          next ret[-1] = last = :hard_nl if last.is_a?(Symbol)
+          ret << (last = :hard_nl)
+        end
+        ret
+      end
+    end
 
-          if part == :nl
-            lws ? yield(current.chop, width - 1) : yield(current, width)
-            current = seq.dup
-            width = 0
-            next lws = false
-          end
+    class Osc
+      attr_reader :to_str, :size
 
-          if part == :hard_nl
-            if width > 0
-              lws ? yield(current.chop, width - 1) : yield(current, width)
-            end
-            seq.clear
-            current = EMPTY.dup
-            width = 0
-            next lws = false
-          end
+      alias to_s to_str
 
-          lws = false
+      def initialize(str)
+        @to_str = str
+        @size = 0
+      end
 
-          if part == :seq
-            current << opt
-            next seq << opt
-          end
+      def inspect = "#{to_s.chop} #{@to_str.inspect}>"
+    end
 
-          # :seq_end
-          next if seq.empty?
-          current << "\e[m"
-          seq.clear
-        end
-        nil
-      end
+    class Csi < Osc
+      def add(str) = (@to_str << str)
     end
 
-    @ambiguous_char_width = 1
+    module CsiEnd
+      class << self
+        attr_reader :to_str, :size
+      end
+      @to_str = "\e[m"
+      @size = 0
+    end
 
     class Word
-      attr_reader :to_str, :size, :chars
+      attr_reader :to_str, :size
+
+      alias to_s to_str
 
       def initialize(char, size)
         @to_str = char.dup
         @size = size
-        @chars = [[char, size]]
       end
 
       def add(char, size)
         @to_str << char
         @size += size
+      end
+
+      def inspect = "#{to_s.chop} #{@size}:#{@to_str.inspect}>"
+    end
+
+    class WordEx < Word
+      attr_reader :chars
+
+      def initialize(char, size)
+        super
+        @chars = [[char, size]]
+      end
+
+      def add(char, size)
         @chars << [char, size]
-        nil
+        super
+      end
+
+      def split(limit)
+        chars = @chars.dup
+        ret = [last = Word.new(*chars.shift)]
+        chars.each do |c, s|
+          next ret << (last = Word.new(c, s)) if last.size + s > limit
+          last.add(c, s)
+        end
+        ret
       end
     end
-    private_constant :Word
+
+    private_constant :Osc, :CsiEnd, :Csi, :Word, :WordEx
+
+    @ambiguous_char_width = 1
 
     ENC = Encoding::UTF_8
     EMPTY = String.new(encoding: ENC).freeze

data/lib/terminal/version.rb

@@ -2,5 +2,5 @@
 
 module Terminal
   # The version number of the gem.
-  VERSION = '0.9.1'
+  VERSION = '0.9.4'
 end

data/lib/terminal.rb

@@ -6,16 +6,21 @@ require_relative 'terminal/input'
 #
 # Terminal access with support for ANSI control codes and
 # [BBCode-like](https://en.wikipedia.org/wiki/BBCode) embedded text attribute
-# syntax.
+# syntax (see {Ansi.bbcode}).
 #
-# It automagically detects whether your terminal supports ANSI features.
+# It automagically detects whether your terminal supports ANSI features, like
+# coloring (see {colors}) or the
+# [CSIu protocol](https://sw.kovidgoyal.net/kitty/keyboard-protocol) support
+# (see {read_key} and {input_mode}). It calculates the display width for Unicode
+# chars (see {Text.width}) and help you to display text with line formatting
+# (see {Text.each_line}).
 #
 module Terminal
   class << self
     # Return true when the current terminal supports ANSI control codes.
     # When the terminal does not support it, {colors} will return `2` as color
     # count and all output methods ({<<}, {print}, {puts}) will not forward
-    # ANSI control codes to the terminal.
+    # ANSI control codes to the terminal, {read_key} will not support CSIu.
     #
     # @attribute [r] ansi?
     # @return [Boolean] whether ANSI control codes are supported

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: terminal_rb
 version: !ruby/object:Gem::Version
-  version: 0.9.1
+  version: 0.9.4
 platform: ruby
 authors:
 - Mike Blumtritt
@@ -34,6 +34,8 @@ files:
 - lib/terminal/ansi/named_colors.rb
 - lib/terminal/detect.rb
 - lib/terminal/input.rb
+- lib/terminal/input/csiu_mode.rb
+- lib/terminal/input/legacy_mode.rb
 - lib/terminal/preload.rb
 - lib/terminal/rspec/helper.rb
 - lib/terminal/text.rb
@@ -47,7 +49,7 @@ metadata:
   rubygems_mfa_required: 'true'
   source_code_uri: https://codeberg.org/mblumtritt/Terminal.rb
   bug_tracker_uri: https://codeberg.org/mblumtritt/Terminal.rb/issues
-  documentation_uri: https://rubydoc.info/gems/terminal_rb/0.9.1/Terminal
+  documentation_uri: https://rubydoc.info/gems/terminal_rb/0.9.4/Terminal
 rdoc_options: []
 require_paths:
 - lib