terminal_rb 0.7.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f0ee278f7b96ba33953b258b8ca66365bbd3e97ea670488711e8ad42aa3e59b3
-  data.tar.gz: de6c7769a32cf5aef25cf8acd055b1e86a5ac5b80eb36ff71afa83eba057f083
+  metadata.gz: 351b0ba282f1686000796ca789653308c722d201286ea7e1e6b99d2802db2b21
+  data.tar.gz: c25af6f120fc06e991b7f2a5f616141ac44d99a72a7d4569228d7822daa730a4
 SHA512:
-  metadata.gz: f7c9198faea2f62bb289f19c3a42c8d271b898b826b1990164bea6eead69b1f78324ec02cc408b3d35a40b915de7e9e59b5d43489971c4ec6222a36a55b4a202
-  data.tar.gz: f61cb0793edf2b27b9455e14df9ee5604c142f72e078cde13655fff055d626d0b3d9566dea2f029954c8b298a1c278af9f6612de4fded640dd1a3c17b7ae2f4d
+  metadata.gz: 31c49a47f6bf38aa08cb8e75e85fe5180d7d676b737392b38e52baebf1ff7669d9fb76d1037bfdb1e13a5683b36a434e41b4001ef2dfc56692ed1229cc7f044d
+  data.tar.gz: 2ba822e7bc9448d577f6f6649abb8b6c8f6fb9c44a76c86d9c9595c78cfd96e9dbda1451d6617e5c180e19a1c40dd0b7b09392fc1894dd3dbe858b7ab526c6da

data/lib/terminal/ansi.rb

@@ -154,7 +154,10 @@ module Terminal
       #
       # @param str [#to_s] string to be modified
       # @return [String] string without ANSI attributes
-      def undecorate(str) = str.to_s.gsub(TEST, '')
+      def undecorate(str)
+        str = str.to_s
+        str.index("\e") ? str.gsub(TEST, '') : str.dup
+      end
 
       # Try to combine given ANSI attributes and colors.
       # The attributes and colors have to be separated by given `separator``.
@@ -220,13 +223,13 @@ module Terminal
       # @param str [#to_s] string to be modified
       # @return [String] string with ANSI attributes
       def bbcode(str)
-        str
-          .to_s
-          .gsub(BBCODE) do |match_str|
-            next match_str if (match = Regexp.last_match[1]).empty?
-            next "[#{match[1..]}]" if match[0] == '\\'
-            try_convert(match) || match_str
-          end
+        str = str.to_s
+        return str.dup unless str.index('[')
+        str.gsub(BBCODE) do |match_str|
+          next match_str if (match = Regexp.last_match[1]).empty?
+          next "[#{match[1..]}]" if match[0] == '\\'
+          try_convert(match) || match_str
+        end
       end
 
       # Remove embedded BBCode-like attributes.
@@ -240,15 +243,15 @@ module Terminal
       # @param str [#to_s] string to be modified
       # @return [String] string without BBCode
       def unbbcode(str)
-        str
-          .to_s
-          .gsub(BBCODE) do |match_str|
-            next match_str if (match = Regexp.last_match[1]).empty?
-            next "[#{match[1..]}]" if match[0] == '\\'
-            next match_str if (match = match.split).empty?
-            next if match.all? { ATTRIBUTES[_1] || COLORS[_1] || _color(_1) }
-            match_str
-          end
+        str = str.to_s
+        return str.dup unless str.index('[')
+        str.gsub(BBCODE) do |match_str|
+          next match_str if (match = Regexp.last_match[1]).empty?
+          next "[#{match[1..]}]" if match[0] == '\\'
+          next match_str if (match = match.split).empty?
+          next if match.all? { ATTRIBUTES[_1] || COLORS[_1] || _color(_1) }
+          match_str
+        end
       end
 
       #
@@ -264,7 +267,21 @@ module Terminal
       #
       # @param str [#to_s] string to be modified
       # @return [String] string without BBCode and ANSI control codes.
-      def plain(str) = unbbcode(str).gsub(TEST, '')
+      def plain(str)
+        str = str.to_s
+        unless str.index('[')
+          return str.index("\e") ? str.gsub(TEST, '') : str.dup
+        end
+        str =
+          str.gsub(BBCODE) do |match_str|
+            next match_str if (match = Regexp.last_match[1]).empty?
+            next "[#{match[1..]}]" if match[0] == '\\'
+            next match_str if (match = match.split).empty?
+            next if match.all? { ATTRIBUTES[_1] || COLORS[_1] || _color(_1) }
+            match_str
+          end
+        str.index("\e") ? str.gsub!(TEST, '') : str
+      end
 
       # Create nice colored text.
       #

data/lib/terminal/text.rb

@@ -3,6 +3,8 @@
 require_relative 'ansi'
 
 module Terminal
+  # Text helper functions.
+  #
   module Text
     class << self
       # Value for {width} of letters whose display width is not precisely
@@ -31,46 +33,85 @@ module Terminal
         str = str.encode(ENC) if str.encoding != ENC
         width = 0
         str.scan(WIDTH_SCANNER) do |sp, gc|
-          next width += __char_width(gc) if gc
+          next width += char_width(gc) if gc
           width += 1 if sp
         end
         width
       end
 
       # Iterate each line of given text.
-      # It can optionally
       #
-      # - interprete embedded BBCode
-      # - remove ANSI control codes
-      # - ignore embedded new line
-      # - limit text output width
-      # - report each line's size
-      #
-      # @param (see Wrap#initialize)
-      # @param (see Wrap#each_line)
-      # @yield (see Wrap#each_line)
-      # @return (see Wrap#each_line)
-      # @raise (see Wrap#each_line)
+      # @param [#to_s, ...] text
+      #   text objects to process
+      # @param [#to_i, nil] limit
+      #   optionally limit line size
+      # @param [true, false] bbcode
+      #   whether to interprete embedded BBCode (see {Ansi.bbcode})
+      # @param [true, false] ansi
+      #   whether to keep embedded ANSI control codes
+      # @param [true, false] ignore_newline
+      #   wheter to ignore embedded line breaks (`"\r\n"` or `"\n"`)
+      # @yield [String] text line
+      # @return [Enumerator] when no block given
+      # @return [nil]
+      # @raise ArgumentError when a `limit` less than `1` is given
       def each_line(
         *text,
+        limit: nil,
         bbcode: true,
         ansi: true,
         ignore_newline: false,
+        &block
+      )
+        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)
+          else
+            to_enum(:lines_in, text, bbcode, ansi, ignore_newline, limit)
+          end
+        elsif block_given?
+          lines(text, bbcode, ansi, ignore_newline, &block)
+        else
+          to_enum(:lines, text, bbcode, ansi, ignore_newline)
+        end
+      end
+      alias each each_line
+
+      # Iterate each line and it's display width of given text.
+      #
+      # @param (see each_line)
+      # @yield [String, Integer] text line and it's display width
+      # @return (see each_line)
+      # @raise (see each_line)
+      def each_line_with_size(
+        *text,
         limit: nil,
-        with_size: false,
+        bbcode: true,
+        ansi: true,
+        ignore_newline: false,
         &block
       )
-        Wrap.new(
-          *text,
-          bbcode: bbcode,
-          ansi: ansi,
-          ignore_newline: ignore_newline
-        ).each_line(limit: limit, with_size: with_size, &block)
+        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)
+          else
+            to_enum(:pairs_in, text, bbcode, ansi, ignore_newline, limit)
+          end
+        elsif block_given?
+          pairs(text, bbcode, ansi, ignore_newline, &block)
+        else
+          to_enum(:pairs, text, bbcode, ansi, ignore_newline)
+        end
       end
+      alias each_with_size each_line_with_size
+
+      private
 
-      # @!visibility private
-      # works for UTF-8 chars only!
-      def __char_width(char)
+      def char_width(char)
         ord = char.ord
         return CONTROL_CHAR_WIDTH[ord] || 2 if ord < 0x20
         return 1 if ord < 0xa1
@@ -80,127 +121,39 @@ module Terminal
         # Halfwidth Dakuten Handakuten
         sco == 0xff9e || sco == 0xff9f ? 2 : 1
       end
-    end
 
-    # Helper class to calculate word-wise text wrapping in various conditions.
-    # Internally used by {Text.each_line}.
-    class Wrap
-      # Create a new instance which may support different conditions.
-      #
-      # @param [#to_s, ...] text
-      #   text objects to process
-      # @param [true, false] bbcode
-      #   whether to interprete embedded BBCode (see {Ansi.bbcode})
-      # @param [true, false] ansi
-      #   whether to keep embedded ANSI control codes
-      # @param [true, false] ignore_newline
-      #   wheter to ignore embedded line breaks (`"\r\n"` or `"\n"`)
-      def initialize(*text, bbcode: true, ansi: true, ignore_newline: false)
-        @parts = []
+      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 @parts << :hard_nl if txt.empty?
+          next yield(:hard_nl) if txt.empty?
           txt = txt.encode(ENC) if txt.encoding != ENC
           word = nil
-          txt.scan(REGEXP) do |nl, csi, osc, space, gc|
-            next word ? word << gc : @parts << (word = Word.new(gc)) if gc
+          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 @parts << :space if space
-            next @parts << newline if nl
+            next yield(:space) if space
+            next yield(newline) if nl
             next unless ansi
-            next @parts << [:seq, osc] if osc
-            next @parts << :seq_end if csi == "\e[m" || csi == "\e[0m"
-            @parts << [:seq, csi]
+            next yield(:seq, osc) if osc
+            next yield(:seq_end) if csi == "\e[m" || csi == "\e[0m"
+            yield(:seq, csi)
           end
-          @parts << :hard_nl
+          yield(word) if word
+          yield(:hard_nl)
         end
-      end
-
-      # Iterate each line of given text.
-      #
-      # @param [#to_i, nil] limit
-      #   optionally limit line size
-      # @param [true, false] with_size
-      #   whether to yield each line with it's display width
-      # @yield [String] line when `with_size` is false
-      # @yield [<String, Integer>] line and it's display width
-      #   when `with_size` is true
-      # @return [Enumerator] when no block is given
-      # @return [nil] when block is given
-      # @raise ArgumentError when a `limit` less than `1` is given
-      def each_line(limit: nil, with_size: false, &block)
-        unless limit
-          return with_size ? pairs(&block) : lines(&block) if block_given?
-          return to_enum(with_size ? :pairs : :lines)
-        end
-        limit = limit.to_i
-        raise(ArgumentError, "invalid limit - #{limit}") if limit < 1
-        if block_given?
-          return with_size ? pairs_in(limit, &block) : lines_in(limit, &block)
-        end
-        to_enum(with_size ? :pairs_in : :lines_in, limit)
-      end
-      alias each each_line
-
-      # @!visibility private
-      def each_word(with_size: false, &block)
-        return with_size ? word_pairs(&block) : words(&block) if block_given?
-        to_enum(with_size ? :word_pairs : :words)
-      end
-
-      # @!visibility private
-      def to_str
-        str = EMPTY.dup
-        seq = EMPTY.dup
-        @parts.each do |part, opt|
-          next str << part if part.is_a?(Word)
-          next str << ' ' if part == :space
-
-          if part == :nl
-            str << "\n"
-            next str << seq.dup
-          end
-
-          if part == :seq
-            str << opt
-            next seq << opt
-          end
-
-          # :seq_end
-          next if seq.empty?
-          str << "\e[m"
-          seq.clear
-        end
-        str
-      end
-      alias to_s to_str
-
-      # @!visibility private
-      def to_a(limit: nil, with_size: false)
-        each_line(limit: limit, with_size: with_size).to_a
-      end
-
-      # @!visibility private
-      def to_ary = each_line.to_a
-
-      private
-
-      def words
-        @parts.each { yield(_1.to_s) if _1.is_a?(Word) }
         nil
       end
 
-      def word_pairs
-        @parts.each { yield(_1.to_s, _1.size) if _1.is_a?(Word) }
-        nil
-      end
-
-      def lines
+      def lines(text, bbcode, ansi, ignore_newline)
         current = EMPTY.dup
         seq = EMPTY.dup
         lws = nil
-        @parts.each do |part, opt|
+        each_part(text, bbcode, ansi, ignore_newline) do |part, opt|
           if part == :space
             next if lws
             current << ' '
@@ -239,12 +192,12 @@ module Terminal
         nil
       end
 
-      def lines_in(limit)
+      def lines_in(text, bbcode, ansi, ignore_newline, limit)
         current = EMPTY.dup
         seq = EMPTY.dup
         width = 0
         lws = nil
-        @parts.each do |part, opt|
+        each_part(text, bbcode, ansi, ignore_newline) do |part, opt|
           if part == :space
             next if lws
             if width.succ < limit
@@ -322,12 +275,12 @@ module Terminal
         nil
       end
 
-      def pairs
+      def pairs(text, bbcode, ansi, ignore_newline)
         current = EMPTY.dup
         seq = EMPTY.dup
         width = 0
         lws = nil
-        @parts.each do |part, opt|
+        each_part(text, bbcode, ansi, ignore_newline) do |part, opt|
           if part == :space
             next if lws
             current << ' '
@@ -371,12 +324,12 @@ module Terminal
         nil
       end
 
-      def pairs_in(limit)
+      def pairs_in(text, bbcode, ansi, ignore_newline, limit)
         current = EMPTY.dup
         seq = EMPTY.dup
         width = 0
         lws = nil
-        @parts.each do |part, opt|
+        each_part(text, bbcode, ansi, ignore_newline) do |part, opt|
           if part == :space
             next if lws
             if width.succ < limit
@@ -457,46 +410,40 @@ module Terminal
         end
         nil
       end
+    end
 
-      class Word
-        attr_reader :to_str, :size, :chars
+    @ambiguous_char_width = 1
 
-        def initialize(char)
-          @to_str = char.dup
-          @size = Text.__char_width(char)
-          @chars = [[char, @size]]
-        end
+    class Word
+      attr_reader :to_str, :size, :chars
 
-        def <<(char)
-          @to_str << char
-          @chars << [char, cw = Text.__char_width(char)]
-          @size += cw
-          self
-        end
+      def initialize(char, size)
+        @to_str = char.dup
+        @size = size
+        @chars = [[char, size]]
+      end
+
+      def add(char, size)
+        @to_str << char
+        @size += size
+        @chars << [char, size]
+        nil
       end
-      private_constant :Word
-
-      REGEXP =
-        /\G(?:
-          (\r?\n)
-          | (\e\[[\d;:\?]*[ABCDEFGHJKSTfminsuhl])
-          | (\e\]\d+(?:;[^\a\e]+)*(?:\a|\e\\))
-          | (\s+)
-          | (\X)
-        )/x
-      private_constant :REGEXP
-
-      ENC = Encoding::UTF_8
-      private_constant :ENC
-
-      EMPTY = String.new(encoding: ENC).freeze
-      private_constant :EMPTY
     end
+    private_constant :Word
 
     ENC = Encoding::UTF_8
-    private_constant :ENC
+    EMPTY = String.new(encoding: ENC).freeze
+    private_constant :ENC, :EMPTY
 
-    @ambiguous_char_width = 1
+    SCAN_EXPR =
+      /\G(?:
+        (\r?\n)
+        | (\e\[[\d;:\?]*[ABCDEFGHJKSTfminsuhl])
+        | (\e\]\d+(?:;[^\a\e]+)*(?:\a|\e\\))
+        | (\s+)
+        | (\X)
+      )/x
 
     WIDTH_SCANNER =
       /\G(?:
@@ -505,7 +452,7 @@ module Terminal
         | (\s+)
         | (\X)
       )/x
-    private_constant :WIDTH_SCANNER
+    private_constant :SCAN_EXPR, :WIDTH_SCANNER
 
     CONTROL_CHAR_WIDTH = {
       0x00 => 0,

data/lib/terminal/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: terminal_rb
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.9.0
 platform: ruby
 authors:
 - Mike Blumtritt