terminal_rb 0.9.3 → 0.9.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 673e2c03057d8f9c6c73d8dbe3f464a70ab796e67b272dd6de58ec44ab82bde8
-  data.tar.gz: 3fa3b10c9370c7ab9113d8f7a961ebd74437fdba76dc34a64716f955df1fae6a
+  metadata.gz: c9409becbf807905a0659436c9e0f5c3644208006e23c038dbf43a621410c7c7
+  data.tar.gz: 7a583438aa3b66faa19a9bbd035ad26d2c74f889b923e2f410d6468291006495
 SHA512:
-  metadata.gz: 91ba6fb64a85db7d30f5a390b8d3b5544ad5080428d832582a5a1ee655dac23e7bdebee185784dccdc5e2ac20eddfb33c64808a93893297769e994522dbdd696
-  data.tar.gz: 435c3f4369383850562d5b95f355bdb45fb4fb235ba9bba7eb451404657552c75e54b6b181c975903f4e6041a73206e08023c1e3fd77bedb3d28fb10f33e5612
+  metadata.gz: 3aa083acc102175661145c924b62d3cee717a9453bb73abc6415800d70193ef957abe998732592d1171244a2393767141254891db15a73b96ff2d76bca5c38d8
+  data.tar.gz: 3375ed736835332ed58078ca090922f483a81b3c7a4e6d10b87c9abb64fc6260a67649c5e4a06147e0fa89bea44d623f6613f803e24f02c171830647864a88f2

data/README.md

@@ -14,7 +14,7 @@ Terminal access with support for ANSI control codes and [BBCode-like](https://en
 - [NO_COLOR convention](https://no-color.org) support
 - markup of text attributes and colors using a [BBCode](https://en.wikipedia.org/wiki/BBCode)-like syntax
 - calculation for correct display width of strings containing Unicdode chars inclusive emojis
-- word-wise text wrapper
+- generation of word-by-word wrapped text
 - supports [CSIu protocol](https://sw.kovidgoyal.net/kitty/keyboard-protocol)
 
 ## Examples
@@ -43,7 +43,7 @@ Terminal::Text.width('ライブラリは中国語、日本語、韓国語のテ
 # => 64
 ```
 
-### Split text word-wise and limit line width to 30 chars
+### Split text word-by-word and limit line width to 30 chars
 
 ```ruby
 Terminal::Text.each_line(<<~TEXT, limit: 30).to_a

data/lib/terminal/ansi.rb

@@ -497,13 +497,15 @@ module Terminal
       # @param [Integer, nil] scale
       #   overall scale size, range 1..7
       # @param [Integer, nil] width
-      #   with on cells, range 0..7
+      #   with in cells, range 0..7
       # @param [Integer, nil] fracn
       #   numerator for the fractional scale, range: 0..15
       # @param [Integer, nil] fracd
       #   denominator for the fractional scale, range: 0..15, > fracn
       # @param [:top, :bottom, :centered, nil] vertical
       #   vertical alignment to use for fractionally scaled text
+      # @param [:left, :right, :centered, nil] horizontal
+      #   horizontal alignment to use for fractionally scaled text
       # @return (see cursor_up)
       def scale(
         text,

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.3'
+  VERSION = '0.9.4'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: terminal_rb
 version: !ruby/object:Gem::Version
-  version: 0.9.3
+  version: 0.9.4
 platform: ruby
 authors:
 - Mike Blumtritt
@@ -49,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.3/Terminal
+  documentation_uri: https://rubydoc.info/gems/terminal_rb/0.9.4/Terminal
 rdoc_options: []
 require_paths:
 - lib