brakeman 6.2.2 → 8.0.4

data/bundle/ruby/{3.1.0/gems/reline-0.5.10 → 3.2.0/gems/reline-0.6.3}/lib/reline/unicode/east_asian_width.rb

@@ -1,6 +1,6 @@
 class Reline::Unicode::EastAsianWidth
   # This is based on EastAsianWidth.txt
-  # UNICODE_VERSION = '15.1.0'
+  # UNICODE_VERSION = '16.0.0'
 
   CHUNK_LAST, CHUNK_WIDTH = [
     [0x1f, 2],
@@ -129,7 +129,7 @@ class Reline::Unicode::EastAsianWidth
     [0x450, 1],
     [0x451, -1],
     [0x482, 1],
-    [0x487, 0],
+    [0x489, 0],
     [0x590, 1],
     [0x5bd, 0],
     [0x5be, 1],
@@ -174,7 +174,7 @@ class Reline::Unicode::EastAsianWidth
     [0x82d, 0],
     [0x858, 1],
     [0x85b, 0],
-    [0x897, 1],
+    [0x896, 1],
     [0x89f, 0],
     [0x8c9, 1],
     [0x8e1, 0],
@@ -356,6 +356,7 @@ class Reline::Unicode::EastAsianWidth
     [0x109d, 0],
     [0x10ff, 1],
     [0x115f, 2],
+    [0x11ff, 0],
     [0x135c, 1],
     [0x135f, 0],
     [0x1711, 1],
@@ -411,8 +412,6 @@ class Reline::Unicode::EastAsianWidth
     [0x1a7e, 1],
     [0x1a7f, 0],
     [0x1aaf, 1],
-    [0x1abd, 0],
-    [0x1abe, 1],
     [0x1ace, 0],
     [0x1aff, 1],
     [0x1b03, 0],
@@ -491,10 +490,6 @@ class Reline::Unicode::EastAsianWidth
     [0x20ab, 1],
     [0x20ac, -1],
     [0x20cf, 1],
-    [0x20dc, 0],
-    [0x20e0, 1],
-    [0x20e1, 0],
-    [0x20e4, 1],
     [0x20f0, 0],
     [0x2102, 1],
     [0x2103, -1],
@@ -646,6 +641,8 @@ class Reline::Unicode::EastAsianWidth
     [0x261c, -1],
     [0x261d, 1],
     [0x261e, -1],
+    [0x262f, 1],
+    [0x2637, 2],
     [0x263f, 1],
     [0x2640, -1],
     [0x2641, 1],
@@ -664,6 +661,8 @@ class Reline::Unicode::EastAsianWidth
     [0x266f, -1],
     [0x267e, 1],
     [0x267f, 2],
+    [0x2689, 1],
+    [0x268f, 2],
     [0x2692, 1],
     [0x2693, 2],
     [0x269d, 1],
@@ -753,19 +752,17 @@ class Reline::Unicode::EastAsianWidth
     [0x3130, 1],
     [0x318e, 2],
     [0x318f, 1],
-    [0x31e3, 2],
+    [0x31e5, 2],
     [0x31ee, 1],
     [0x321e, 2],
     [0x321f, 1],
     [0x3247, 2],
     [0x324f, -1],
-    [0x4dbf, 2],
-    [0x4dff, 1],
     [0xa48c, 2],
     [0xa48f, 1],
     [0xa4c6, 2],
     [0xa66e, 1],
-    [0xa66f, 0],
+    [0xa672, 0],
     [0xa673, 1],
     [0xa67d, 0],
     [0xa69d, 1],
@@ -838,6 +835,10 @@ class Reline::Unicode::EastAsianWidth
     [0xabed, 0],
     [0xabff, 1],
     [0xd7a3, 2],
+    [0xd7af, 1],
+    [0xd7c6, 0],
+    [0xd7ca, 1],
+    [0xd7fb, 0],
     [0xdfff, 1],
     [0xf8ff, -1],
     [0xfaff, 2],
@@ -879,9 +880,11 @@ class Reline::Unicode::EastAsianWidth
     [0x10ae6, 0],
     [0x10d23, 1],
     [0x10d27, 0],
+    [0x10d68, 1],
+    [0x10d6d, 0],
     [0x10eaa, 1],
     [0x10eac, 0],
-    [0x10efc, 1],
+    [0x10efb, 1],
     [0x10eff, 0],
     [0x10f45, 1],
     [0x10f50, 0],
@@ -943,6 +946,16 @@ class Reline::Unicode::EastAsianWidth
     [0x1136c, 0],
     [0x1136f, 1],
     [0x11374, 0],
+    [0x113ba, 1],
+    [0x113c0, 0],
+    [0x113cd, 1],
+    [0x113ce, 0],
+    [0x113cf, 1],
+    [0x113d0, 0],
+    [0x113d1, 1],
+    [0x113d2, 0],
+    [0x113e0, 1],
+    [0x113e2, 0],
     [0x11437, 1],
     [0x1143f, 0],
     [0x11441, 1],
@@ -982,6 +995,8 @@ class Reline::Unicode::EastAsianWidth
     [0x116b6, 1],
     [0x116b7, 0],
     [0x1171c, 1],
+    [0x1171d, 0],
+    [0x1171e, 1],
     [0x1171f, 0],
     [0x11721, 1],
     [0x11725, 0],
@@ -1059,10 +1074,16 @@ class Reline::Unicode::EastAsianWidth
     [0x11f40, 0],
     [0x11f41, 1],
     [0x11f42, 0],
+    [0x11f59, 1],
+    [0x11f5a, 0],
     [0x1343f, 1],
     [0x13440, 0],
     [0x13446, 1],
     [0x13455, 0],
+    [0x1611d, 1],
+    [0x16129, 0],
+    [0x1612c, 1],
+    [0x1612f, 0],
     [0x16aef, 1],
     [0x16af4, 0],
     [0x16b2f, 1],
@@ -1080,7 +1101,7 @@ class Reline::Unicode::EastAsianWidth
     [0x187f7, 2],
     [0x187ff, 1],
     [0x18cd5, 2],
-    [0x18cff, 1],
+    [0x18cfe, 1],
     [0x18d08, 2],
     [0x1afef, 1],
     [0x1aff3, 2],
@@ -1116,6 +1137,10 @@ class Reline::Unicode::EastAsianWidth
     [0x1d1ad, 0],
     [0x1d241, 1],
     [0x1d244, 0],
+    [0x1d2ff, 1],
+    [0x1d356, 2],
+    [0x1d35f, 1],
+    [0x1d376, 2],
     [0x1d9ff, 1],
     [0x1da36, 0],
     [0x1da3a, 1],
@@ -1148,6 +1173,8 @@ class Reline::Unicode::EastAsianWidth
     [0x1e2ef, 0],
     [0x1e4eb, 1],
     [0x1e4ef, 0],
+    [0x1e5ed, 1],
+    [0x1e5ef, 0],
     [0x1e8cf, 1],
     [0x1e8d6, 0],
     [0x1e943, 1],
@@ -1241,15 +1268,13 @@ class Reline::Unicode::EastAsianWidth
     [0x1fa6f, 1],
     [0x1fa7c, 2],
     [0x1fa7f, 1],
-    [0x1fa88, 2],
-    [0x1fa8f, 1],
-    [0x1fabd, 2],
-    [0x1fabe, 1],
-    [0x1fac5, 2],
+    [0x1fa89, 2],
+    [0x1fa8e, 1],
+    [0x1fac6, 2],
     [0x1facd, 1],
-    [0x1fadb, 2],
-    [0x1fadf, 1],
-    [0x1fae8, 2],
+    [0x1fadc, 2],
+    [0x1fade, 1],
+    [0x1fae9, 2],
     [0x1faef, 1],
     [0x1faf8, 2],
     [0x1ffff, 1],

data/bundle/ruby/3.2.0/gems/reline-0.6.3/lib/reline/unicode.rb

@@ -0,0 +1,421 @@
+class Reline::Unicode
+  EscapedPairs = {
+    0x00 => '^@',
+    0x01 => '^A', # C-a
+    0x02 => '^B',
+    0x03 => '^C',
+    0x04 => '^D',
+    0x05 => '^E',
+    0x06 => '^F',
+    0x07 => '^G',
+    0x08 => '^H', # Backspace
+    0x09 => '^I',
+    0x0A => '^J',
+    0x0B => '^K',
+    0x0C => '^L',
+    0x0D => '^M', # Enter
+    0x0E => '^N',
+    0x0F => '^O',
+    0x10 => '^P',
+    0x11 => '^Q',
+    0x12 => '^R',
+    0x13 => '^S',
+    0x14 => '^T',
+    0x15 => '^U',
+    0x16 => '^V',
+    0x17 => '^W',
+    0x18 => '^X',
+    0x19 => '^Y',
+    0x1A => '^Z', # C-z
+    0x1B => '^[', # C-[ C-3
+    0x1C => '^\\', # C-\
+    0x1D => '^]', # C-]
+    0x1E => '^^', # C-~ C-6
+    0x1F => '^_', # C-_ C-7
+    0x7F => '^?', # C-? C-8
+  }
+
+  NON_PRINTING_START = "\1"
+  NON_PRINTING_END = "\2"
+  CSI_REGEXP = /\e\[[\x30-\x3f]*[\x20-\x2f]*[a-zA-Z]/
+  OSC_REGEXP = /\e\]\d+(?:;[^;\a\e]+)*(?:\a|\e\\)/
+  WIDTH_SCANNER = /\G(?:(#{NON_PRINTING_START})|(#{NON_PRINTING_END})|(#{CSI_REGEXP})|(#{OSC_REGEXP})|(\X))/o
+
+  def self.escape_for_print(str)
+    str.chars.map! { |gr|
+      case gr
+      when -"\n"
+        gr
+      when -"\t"
+        -'  '
+      else
+        EscapedPairs[gr.ord] || gr
+      end
+    }.join
+  end
+
+  def self.safe_encode(str, encoding)
+    # Reline only supports utf-8 convertible string.
+    converted = str.encode(encoding, invalid: :replace, undef: :replace)
+    return converted if str.encoding == Encoding::UTF_8 || converted.encoding == Encoding::UTF_8 || converted.ascii_only?
+
+    # This code is essentially doing the same thing as
+    # `str.encode(utf8, **replace_options).encode(encoding, **replace_options)`
+    # but also avoids unnecessary irreversible encoding conversion.
+    converted.gsub(/\X/) do |c|
+      c.encode(Encoding::UTF_8)
+      c
+    rescue Encoding::UndefinedConversionError
+      '?'
+    end
+  end
+
+  require 'reline/unicode/east_asian_width'
+
+  def self.east_asian_width(ord)
+    chunk_index = EastAsianWidth::CHUNK_LAST.bsearch_index { |o| ord <= o }
+    size = EastAsianWidth::CHUNK_WIDTH[chunk_index]
+    size == -1 ? Reline.ambiguous_width : size
+  end
+
+  def self.get_mbchar_width(mbchar)
+    ord = mbchar.ord
+    if ord <= 0x1F # in EscapedPairs
+      return 2
+    elsif mbchar.length == 1 && ord <= 0x7E # printable ASCII chars
+      return 1
+    end
+
+    utf8_mbchar = mbchar.encode(Encoding::UTF_8)
+    zwj = false
+    utf8_mbchar.chars.sum do |c|
+      if zwj
+        zwj = false
+        0
+      elsif c.ord == 0x200D # Zero Width Joiner
+        zwj = true
+        0
+      else
+        east_asian_width(c.ord)
+      end
+    end
+  end
+
+  def self.calculate_width(str, allow_escape_code = false)
+    if allow_escape_code
+      width = 0
+      rest = str.encode(Encoding::UTF_8)
+      in_zero_width = false
+      rest.scan(WIDTH_SCANNER) do |non_printing_start, non_printing_end, csi, osc, gc|
+        case
+        when non_printing_start
+          in_zero_width = true
+        when non_printing_end
+          in_zero_width = false
+        when csi, osc
+        when gc
+          unless in_zero_width
+            width += get_mbchar_width(gc)
+          end
+        end
+      end
+      width
+    else
+      str.encode(Encoding::UTF_8).grapheme_clusters.inject(0) { |w, gc|
+        w + get_mbchar_width(gc)
+      }
+    end
+  end
+
+  # This method is used by IRB
+  def self.split_by_width(str, max_width)
+    lines = split_line_by_width(str, max_width)
+    [lines, lines.size]
+  end
+
+  def self.split_line_by_width(str, max_width, encoding = str.encoding, offset: 0)
+    lines = [String.new(encoding: encoding)]
+    width = offset
+    rest = str.encode(Encoding::UTF_8)
+    in_zero_width = false
+    seq = String.new(encoding: encoding)
+    rest.scan(WIDTH_SCANNER) do |non_printing_start, non_printing_end, csi, osc, gc|
+      case
+      when non_printing_start
+        in_zero_width = true
+      when non_printing_end
+        in_zero_width = false
+      when csi
+        lines.last << csi
+        unless in_zero_width
+          if csi == -"\e[m" || csi == -"\e[0m"
+            seq.clear
+          else
+            seq << csi
+          end
+        end
+      when osc
+        lines.last << osc
+        seq << osc unless in_zero_width
+      when gc
+        unless in_zero_width
+          mbchar_width = get_mbchar_width(gc)
+          if (width += mbchar_width) > max_width
+            width = mbchar_width
+            lines << seq.dup
+          end
+        end
+        lines.last << gc
+      end
+    end
+    # The cursor moves to next line in first
+    if width == max_width
+      lines << String.new(encoding: encoding)
+    end
+    lines
+  end
+
+  def self.strip_non_printing_start_end(prompt)
+    prompt.gsub(/\x01([^\x02]*)(?:\x02|\z)/) { $1 }
+  end
+
+  # Take a chunk of a String cut by width with escape sequences.
+  def self.take_range(str, start_col, max_width)
+    take_mbchar_range(str, start_col, max_width).first
+  end
+
+  def self.take_mbchar_range(str, start_col, width, cover_begin: false, cover_end: false, padding: false)
+    chunk = String.new(encoding: str.encoding)
+
+    end_col = start_col + width
+    total_width = 0
+    rest = str.encode(Encoding::UTF_8)
+    in_zero_width = false
+    chunk_start_col = nil
+    chunk_end_col = nil
+    has_csi = false
+    rest.scan(WIDTH_SCANNER) do |non_printing_start, non_printing_end, csi, osc, gc|
+      case
+      when non_printing_start
+        in_zero_width = true
+      when non_printing_end
+        in_zero_width = false
+      when csi
+        has_csi = true
+        chunk << csi
+      when osc
+        chunk << osc
+      when gc
+        if in_zero_width
+          chunk << gc
+          next
+        end
+
+        mbchar_width = get_mbchar_width(gc)
+        prev_width = total_width
+        total_width += mbchar_width
+
+        if (cover_begin || padding ? total_width <= start_col : prev_width < start_col)
+          # Current character haven't reached start_col yet
+          next
+        elsif padding && !cover_begin && prev_width < start_col && start_col < total_width
+          # Add preceding padding. This padding might have background color.
+          chunk << ' ' * (total_width - start_col)
+          chunk_start_col ||= start_col
+          chunk_end_col = total_width
+          next
+        elsif (cover_end ? prev_width < end_col : total_width <= end_col)
+          # Current character is in the range
+          chunk << gc
+          chunk_start_col ||= prev_width
+          chunk_end_col = total_width
+          break if total_width >= end_col
+        else
+          # Current character exceeds end_col
+          if padding && end_col < total_width
+            # Add succeeding padding. This padding might have background color.
+            chunk << ' ' * (end_col - prev_width)
+            chunk_start_col ||= prev_width
+            chunk_end_col = end_col
+          end
+          break
+        end
+      end
+    end
+    chunk_start_col ||= start_col
+    chunk_end_col ||= start_col
+    if padding && chunk_end_col < end_col
+      # Append padding. This padding should not include background color.
+      chunk << "\e[0m" if has_csi
+      chunk << ' ' * (end_col - chunk_end_col)
+      chunk_end_col = end_col
+    end
+    [chunk, chunk_start_col, chunk_end_col - chunk_start_col]
+  end
+
+  def self.get_next_mbchar_size(line, byte_pointer)
+    grapheme = line.byteslice(byte_pointer..-1).grapheme_clusters.first
+    grapheme ? grapheme.bytesize : 0
+  end
+
+  def self.get_prev_mbchar_size(line, byte_pointer)
+    if byte_pointer.zero?
+      0
+    else
+      grapheme = line.byteslice(0..(byte_pointer - 1)).grapheme_clusters.last
+      grapheme ? grapheme.bytesize : 0
+    end
+  end
+
+  def self.em_forward_word(line, byte_pointer)
+    gcs = line.byteslice(byte_pointer..).grapheme_clusters
+    nonwords = gcs.take_while { |c| !word_character?(c) }
+    words = gcs.drop(nonwords.size).take_while { |c| word_character?(c) }
+    nonwords.sum(&:bytesize) + words.sum(&:bytesize)
+  end
+
+  def self.em_forward_word_with_capitalization(line, byte_pointer)
+    gcs = line.byteslice(byte_pointer..).grapheme_clusters
+    nonwords = gcs.take_while { |c| !word_character?(c) }
+    words = gcs.drop(nonwords.size).take_while { |c| word_character?(c) }
+    [nonwords.sum(&:bytesize) + words.sum(&:bytesize), nonwords.join + words.join.capitalize]
+  end
+
+  def self.em_backward_word(line, byte_pointer)
+    gcs = line.byteslice(0, byte_pointer).grapheme_clusters.reverse
+    nonwords = gcs.take_while { |c| !word_character?(c) }
+    words = gcs.drop(nonwords.size).take_while { |c| word_character?(c) }
+    nonwords.sum(&:bytesize) + words.sum(&:bytesize)
+  end
+
+  def self.em_big_backward_word(line, byte_pointer)
+    gcs = line.byteslice(0, byte_pointer).grapheme_clusters.reverse
+    spaces = gcs.take_while { |c| space_character?(c) }
+    nonspaces = gcs.drop(spaces.size).take_while { |c| !space_character?(c) }
+    spaces.sum(&:bytesize) + nonspaces.sum(&:bytesize)
+  end
+
+  def self.ed_transpose_words(line, byte_pointer)
+    gcs = line.byteslice(0, byte_pointer).grapheme_clusters
+    pos = gcs.size
+    gcs += line.byteslice(byte_pointer..).grapheme_clusters
+    pos += 1 while pos < gcs.size && !word_character?(gcs[pos])
+    if pos == gcs.size # 'aaa  bbb [cursor] '
+      pos -= 1 while pos > 0 && !word_character?(gcs[pos - 1])
+      second_word_end = gcs.size
+    else # 'aaa  [cursor]bbb'
+      pos += 1 while pos < gcs.size && word_character?(gcs[pos])
+      second_word_end = pos
+    end
+    pos -= 1 while pos > 0 && word_character?(gcs[pos - 1])
+    second_word_start = pos
+    pos -= 1 while pos > 0 && !word_character?(gcs[pos - 1])
+    first_word_end = pos
+    pos -= 1 while pos > 0 && word_character?(gcs[pos - 1])
+    first_word_start = pos
+
+    [first_word_start, first_word_end, second_word_start, second_word_end].map do |idx|
+      gcs.take(idx).sum(&:bytesize)
+    end
+  end
+
+  def self.vi_big_forward_word(line, byte_pointer)
+    gcs = line.byteslice(byte_pointer..).grapheme_clusters
+    nonspaces = gcs.take_while { |c| !space_character?(c) }
+    spaces = gcs.drop(nonspaces.size).take_while { |c| space_character?(c) }
+    nonspaces.sum(&:bytesize) + spaces.sum(&:bytesize)
+  end
+
+  def self.vi_big_forward_end_word(line, byte_pointer)
+    gcs = line.byteslice(byte_pointer..).grapheme_clusters
+    first = gcs.shift(1)
+    spaces = gcs.take_while { |c| space_character?(c) }
+    nonspaces = gcs.drop(spaces.size).take_while { |c| !space_character?(c) }
+    matched = spaces + nonspaces
+    matched.pop
+    first.sum(&:bytesize) + matched.sum(&:bytesize)
+  end
+
+  def self.vi_big_backward_word(line, byte_pointer)
+    gcs = line.byteslice(0, byte_pointer).grapheme_clusters.reverse
+    spaces = gcs.take_while { |c| space_character?(c) }
+    nonspaces = gcs.drop(spaces.size).take_while { |c| !space_character?(c) }
+    spaces.sum(&:bytesize) + nonspaces.sum(&:bytesize)
+  end
+
+  def self.vi_forward_word(line, byte_pointer, drop_terminate_spaces = false)
+    gcs = line.byteslice(byte_pointer..).grapheme_clusters
+    return 0 if gcs.empty?
+
+    c = gcs.first
+    matched =
+      if word_character?(c)
+        gcs.take_while { |c| word_character?(c) }
+      elsif space_character?(c)
+        gcs.take_while { |c| space_character?(c) }
+      else
+        gcs.take_while { |c| !word_character?(c) && !space_character?(c) }
+      end
+
+    return matched.sum(&:bytesize) if drop_terminate_spaces
+
+    spaces = gcs.drop(matched.size).take_while { |c| space_character?(c) }
+    matched.sum(&:bytesize) + spaces.sum(&:bytesize)
+  end
+
+  def self.vi_forward_end_word(line, byte_pointer)
+    gcs = line.byteslice(byte_pointer..).grapheme_clusters
+    return 0 if gcs.empty?
+    return gcs.first.bytesize if gcs.size == 1
+
+    start = gcs.shift
+    skips = [start]
+    if space_character?(start) || space_character?(gcs.first)
+      spaces = gcs.take_while { |c| space_character?(c) }
+      skips += spaces
+      gcs.shift(spaces.size)
+    end
+    start_with_word = word_character?(gcs.first)
+    matched = gcs.take_while { |c| start_with_word ? word_character?(c) : !word_character?(c) && !space_character?(c) }
+    matched.pop
+    skips.sum(&:bytesize) + matched.sum(&:bytesize)
+  end
+
+  def self.vi_backward_word(line, byte_pointer)
+    gcs = line.byteslice(0, byte_pointer).grapheme_clusters.reverse
+    spaces = gcs.take_while { |c| space_character?(c) }
+    gcs.shift(spaces.size)
+    start_with_word = word_character?(gcs.first)
+    matched = gcs.take_while { |c| start_with_word ? word_character?(c) : !word_character?(c) && !space_character?(c) }
+    spaces.sum(&:bytesize) + matched.sum(&:bytesize)
+  end
+
+  def self.common_prefix(list, ignore_case: false)
+    return '' if list.empty?
+
+    common_prefix_gcs = list.first.grapheme_clusters
+    list.each do |item|
+      gcs = item.grapheme_clusters
+      common_prefix_gcs = common_prefix_gcs.take_while.with_index do |gc, i|
+        ignore_case ? gc.casecmp?(gcs[i]) : gc == gcs[i]
+      end
+    end
+    common_prefix_gcs.join
+  end
+
+  def self.vi_first_print(line)
+    gcs = line.grapheme_clusters
+    spaces = gcs.take_while { |c| space_character?(c) }
+    spaces.sum(&:bytesize)
+  end
+
+  def self.word_character?(s)
+    s.encode(Encoding::UTF_8).match?(/\p{Word}/) if s
+  rescue Encoding::UndefinedConversionError
+    false
+  end
+
+  def self.space_character?(s)
+    s.match?(/\s/) if s
+  end
+end

data/bundle/ruby/3.2.0/gems/reline-0.6.3/lib/reline/version.rb

@@ -0,0 +1,3 @@
+module Reline
+  VERSION = '0.6.3'
+end