reflex-terminal 0.1.0 → 0.2.0

data/test/test_renderer.rb

@@ -31,10 +31,10 @@ class TestRenderer < Test::Unit::TestCase
     r = renderer f
     # the font crosses back as a copy, so it is the same one by its own
     # measure rather than by object
-    assert_equal f.name,        r.font.name
-    assert_equal f.size,        r.font.size
-    assert_equal f.width('M'),  r.cell_width
-    assert_equal f.height.ceil, r.cell_height
+    assert_equal f.name,            r.font.name
+    assert_equal f.size,            r.font.size
+    assert_equal f.width('M').ceil, r.cell_width
+    assert_equal f.height.ceil,     r.cell_height
 
     # the atlas holds glyphs of one size, so it goes with the old font
     r.bake_glyphs terminal('hello')
@@ -66,6 +66,124 @@ class TestRenderer < Test::Unit::TestCase
     assert_equal ascii + 3, r.glyph_count
   end
 
+  def test_bake_glyphs_by_style()
+    r     = renderer
+    ascii = (0x20..0x7e).size
+
+    # a styled cell is another glyph even for a character the seed holds:
+    # each face keeps glyphs of its own, over the one shared atlas
+    r.bake_glyphs terminal("a \e[1ma\e[0m \e[3ma\e[0m \e[1;3ma\e[0m")
+    assert_equal ascii + 3, r.glyph_count
+
+    # and only the regular face is seeded with ascii
+    r.bake_glyphs terminal("\e[1mb")
+    assert_equal ascii + 4, r.glyph_count
+  end
+
+  def test_draw_styles()
+    r = renderer
+    t = terminal "aaaa \e[1maaaa\e[0m \e[3maaaa\e[0m"
+    r.bake_glyphs t
+
+    # the same character in another style cannot draw the same
+    plain  = pixels(r, terminal('aaaa'))
+    bold   = pixels(r, terminal("\e[1maaaa"))
+    italic = pixels(r, terminal("\e[3maaaa"))
+    assert_not_equal plain, bold
+    assert_not_equal plain, italic
+    assert_not_equal bold,  italic
+  end
+
+  def test_draw_decorations()
+    r      = renderer
+    styles = {
+      single:        "\e[4m",
+      double:        "\e[21m",
+      curly:         "\e[4:3m",
+      dotted:        "\e[4:4m",
+      dashed:        "\e[4:5m",
+      strikethrough: "\e[9m",
+      overline:      "\e[53m",
+    }
+    r.bake_glyphs terminal('aaaa')
+
+    # every decoration adds its own marks, and no two draw the same
+    plain = pixels(r, terminal('aaaa'))
+    drawn = styles.map {|name, sgr| [name, pixels(r, terminal("#{sgr}aaaa"))]}
+    drawn.each {|name, px| assert_not_equal plain, px, name}
+    drawn.combination(2).each do |(n1, p1), (n2, p2)|
+      assert_not_equal p1, p2, "#{n1} vs #{n2}"
+    end
+  end
+
+  def test_draw_decoration_colors()
+    r = renderer
+    r.bake_glyphs terminal('aaaa')
+
+    # SGR 58 colors the line apart from the text, and SGR 59 hands it back
+    default = pixels(r, terminal("\e[4maaaa"))
+    red     = pixels(r, terminal("\e[4m\e[58:2::255:0:0maaaa"))
+    reset   = pixels(r, terminal("\e[4m\e[58:2::255:0:0m\e[59maaaa"))
+    assert_not_equal default, red
+    assert_equal     default, reset
+  end
+
+  def test_background_alpha()
+    r = renderer
+    assert_equal 1, r.background_alpha
+    assert_raise(ArgumentError) {r.background_alpha = 1.5}
+
+    # the theme background thins out, while a cell the child colored
+    # itself stays opaque over it
+    r.background_alpha = 0.5
+    assert_in_delta 0.5, pixels(r, terminal('')).first.last, 1.0 / 255
+
+    r.background_alpha = 0
+    assert_equal [0, 0, 0, 0], pixels(r, terminal('')).first
+    assert_equal 1, pixels(r, terminal("\e[41m ")).first.last
+
+    # a cell colored like the theme was still colored by the child, so it
+    # stays opaque rather than joining the background it happens to match
+    assert_equal 1, pixels(r, terminal("\e[48;2;0;0;0m ")).first.last
+  end
+
+  def test_draw_blink()
+    r = renderer
+    r.bake_glyphs terminal("\e[5;4mhello")
+    lit   = pixels(r, terminal("\e[5;4mhello"))
+    plain = pixels(r, terminal('hello'))
+
+    # the off phase hides the glyphs and their decorations, but not the
+    # background, and leaves text without the attribute alone
+    r.blink_visible = false
+    assert_equal     pixels(r, terminal('')), pixels(r, terminal("\e[5;4mhello"))
+    assert_not_equal pixels(r, terminal('')), pixels(r, terminal("\e[5;41mhello"))
+    assert_equal     plain,                   pixels(r, terminal('hello'))
+
+    r.blink_visible = true
+    assert_equal lit, pixels(r, terminal("\e[5;4mhello"))
+  end
+
+  def test_draw_invisible()
+    r = renderer
+    r.bake_glyphs terminal('hello')
+
+    # conceal hides the glyphs, not the cell or its decorations
+    assert_equal     pixels(r, terminal('')),      pixels(r, terminal("\e[8mhello"))
+    assert_not_equal pixels(r, terminal('hello')), pixels(r, terminal("\e[8mhello"))
+    assert_not_equal pixels(r, terminal('')),      pixels(r, terminal("\e[8;4mhello"))
+    assert_not_equal pixels(r, terminal('')),      pixels(r, terminal("\e[8;41mhello"))
+  end
+
+  def test_bake_glyphs_skips_concealed()
+    r     = renderer
+    ascii = (0x20..0x7e).size
+
+    # a concealed span draws no glyphs, so it bakes none either
+    r.bake_glyphs terminal("\e[8mあ")
+    assert_equal ascii, r.glyph_count
+  end
+
   def test_draw()
     r = renderer
     t = terminal "hello \e[31mworld\e[0m"

data/test/test_terminal.rb

@@ -36,6 +36,22 @@ class TestTerminal < Test::Unit::TestCase
     R::KeyEvent.new R::KeyEvent::UP, chars, code, modifiers, 0
   end
 
+  # A spawned child is forked from this process, so its parent id and the
+  # script it was handed are enough to pick it out from everything running.
+  def child_pids(script)
+    `ps -eo pid,ppid,command`.lines.drop(1).filter_map do |line|
+      pid, ppid, command = line.strip.split ' ', 3
+      pid.to_i if ppid.to_i == Process.pid && command.include?(script)
+    end
+  end
+
+  def process_alive?(pid)
+    Process.kill 0, pid
+    true
+  rescue Errno::ESRCH
+    false
+  end
+
   def wait_for(t, timeout = 5)
     deadline = Time.now + timeout
     until yield
@@ -66,10 +82,10 @@ class TestTerminal < Test::Unit::TestCase
     spans = t.each_span.to_a
     assert_equal 2, spans.size
 
-    x, y, width, text, fg, bg, flags = spans[0]
-    assert_equal [0, 0, 3, %q[hi ], nil, nil, 0], [x, y, width, text, fg, bg, flags]
+    x, y, width, text, fg, bg, ul, flags = spans[0]
+    assert_equal [0, 0, 3, %q[hi ], nil, nil, nil, 0], [x, y, width, text, fg, bg, ul, flags]
 
-    x, y, width, text, fg, bg, flags = spans[1]
+    x, y, width, text, fg, bg, ul, flags = spans[1]
     assert_equal [3, 0, 3, %q[red]], [x, y, width, text]
     assert_kind_of Integer, fg
     assert_nil bg
@@ -94,17 +110,56 @@ class TestTerminal < Test::Unit::TestCase
     assert_false t.update
   end
 
+  def test_update_sees_a_bare_cursor_motion()
+    t = terminal 80, 4
+    t.update
+
+    # moving the cursor dirties no cell, but whoever draws the screen
+    # draws the cursor too, so it has to count as damage
+    t.feed "\e[C"
+    assert_true  t.update
+    assert_false t.update
+  end
+
   def test_each_span_attributes()
     t = terminal 80, 4
     t.feed "\e[1mB\e[0m \e[4mU\e[0m \e[7mR"
     t.update
 
-    flags = t.each_span.map {|x, y, w, str, fg, bg, flags| flags}
+    flags = t.each_span.map {|x, y, w, str, fg, bg, ul, flags| flags}
     assert_equal T::BOLD,    flags[0]  & T::BOLD
     assert_equal 1,          (flags[2] & T::UNDERLINE_MASK) >> T::UNDERLINE_SHIFT
     assert_equal T::INVERSE, flags[4]  & T::INVERSE
   end
 
+  def test_each_span_underline_color()
+    t = terminal 80, 4
+    t.feed "\e]4;12;#123456\a"# pin palette 12, whose default is the theme's
+    t.feed "\e[4mA\e[58:2::255:0:0mB\e[58:5:12mC\e[59mD"
+    t.update
+
+    uls = t.each_span.map {|x, y, w, str, fg, bg, ul, flags| ul}
+    assert_equal 4,        uls.size# one span per color
+    assert_nil   uls[0]
+    assert_equal 0xff0000, uls[1]
+    assert_equal 0x123456, uls[2]
+    assert_nil   uls[3]
+  end
+
+  def test_blinking()
+    t = terminal 20, 4
+    t.update
+    assert_false t.blinking?
+
+    t.feed "\e[5mB"
+    t.update
+    assert_true t.blinking?
+
+    t.feed "\e[H\e[2J"
+    t.update
+    assert_false t.blinking?
+  end
+
   def test_wide_chars()
     t = terminal 20, 4
     t.feed %q[あい]
@@ -281,6 +336,17 @@ class TestTerminal < Test::Unit::TestCase
     assert_equal 'A', t.read_pending_input
   end
 
+  def test_write_key_kitty_arrows()
+    t = terminal
+    # macos delivers an arrow with its function-key character (U+F702) as
+    # chars. legacy encoding takes the key over the text, but the kitty
+    # protocol sends the text when there is one, so the character has to
+    # be recognized as a key rather than text
+    t.feed "\e[>1u"
+    t.write_key key_down("\uF702", R::KEY_LEFT)
+    assert_equal "\e[D", t.read_pending_input
+  end
+
   def test_write_key_ctrl()
     t = terminal
     # ghostty leaves these to the kitty protocol (fixterms), so they would
@@ -322,6 +388,17 @@ class TestTerminal < Test::Unit::TestCase
     assert_equal "\e[13;1:3u", t.read_pending_input
   end
 
+  def test_write_key_release_of_committed_text()
+    t = terminal
+    # a key event synthesized for a committed text carries the text as chars
+    # and no key at all; its release must not write the text a second time
+    t.feed "\e[>3u"# report event types
+    t.write_key key_down('あ', -1)# KEY_NONE
+    assert_equal 'あ'.b, t.read_pending_input
+    t.write_key key_up('あ', -1)
+    assert_equal '', t.read_pending_input
+  end
+
   def test_read_pending_input()
     t = terminal
     t.write_key key_down("\r", R::KEY_ENTER)
@@ -388,6 +465,24 @@ class TestTerminal < Test::Unit::TestCase
     assert_include text(t), 'after close'
   end
 
+  def test_close_ends_the_child()
+    # a child that never reads its end of the terminal, so nothing short of
+    # a signal ends it. alive? says nothing about that: close() forgets the
+    # process, and a forgotten one is reported gone whether it is or not.
+    # The comment is a name, so that no other test's child answers to it
+    script = 'sleep# close-test'
+
+    t = terminal 40, 6
+    t.spawn(*ruby(script))
+    wait_for(t) {t.alive?}
+
+    pids = child_pids script
+    assert_equal 1, pids.size
+
+    t.close
+    assert_false process_alive?(pids.first)
+  end unless win32?# child_pids reads ps
+
   def test_spawn_with_args()
     t = terminal 40, 6
     t.spawn(*ruby('print "spawned"'))
@@ -459,16 +554,76 @@ class TestTerminal < Test::Unit::TestCase
     assert_equal "\e[<0;2;2M", t.read_pending_input# cell (2, 2), left press
   end
 
+  def test_write_pointer_cancel()
+    t = terminal 40, 10
+    t.resize 40, 10, cell_width: 8, cell_height: 16
+    t.feed "\e[?1000h\e[?1006h"# normal tracking + SGR format
+
+    mouse = R::Pointer::MOUSE
+    left  = R::Pointer::MOUSE_LEFT
+    right = R::Pointer::MOUSE_RIGHT
+    press = -> types {R::PointerEvent.new(
+      R::Pointer.new(0, mouse | types, R::Pointer::DOWN, [12, 20], 0, 1, false, 0))}
+
+    t.read_pending_input
+    t.write_pointer press[left]
+    assert_equal "\e[<0;2;2M", t.read_pending_input
+    t.write_pointer press[right]
+    assert_equal "\e[<2;2;2M", t.read_pending_input
+
+    # a cancel carries every button being pressed, and the child hears each
+    # of them released
+    t.write_pointer R::PointerEvent.new(
+      R::Pointer.new(
+        0, mouse | left | right, R::Pointer::CANCEL, [12, 20], 0, 1, false, 0))
+    assert_equal "\e[<0;2;2m\e[<2;2;2m", t.read_pending_input
+  end
+
+  def test_mouse_encoding_with_a_fractional_cell()
+    # rounding the cell width would land this press cells off
+    t = terminal 100, 10
+    t.resize 100, 10, cell_width: 8.43, cell_height: 18.62
+    t.feed "\e[?1000h\e[?1006h"
+
+    types = R::Pointer::MOUSE | R::Pointer::MOUSE_LEFT
+    t.read_pending_input
+    t.write_pointer R::PointerEvent.new(
+      R::Pointer.new(0, types, R::Pointer::DOWN, [79 * 8.43 + 4, 5], 0, 1, false, 0))
+    assert_equal "\e[<0;80;1M", t.read_pending_input
+  end
+
+  def test_mouse_encoding_in_sgr_pixels_mode()
+    # the offset inside the cell survives, scaled onto the integral grid
+    t = terminal 100, 10
+    t.resize 100, 10, cell_width: 8.43, cell_height: 18.62
+    t.feed "\e[?1000h\e[?1016h"
+
+    types = R::Pointer::MOUSE | R::Pointer::MOUSE_LEFT
+    t.read_pending_input
+    t.write_pointer R::PointerEvent.new(
+      R::Pointer.new(0, types, R::Pointer::DOWN, [79 * 8.43 + 2, 5], 0, 1, false, 0))
+    assert_equal "\e[<0;634;5M", t.read_pending_input
+  end
+
   def test_write_wheel()
     t = terminal 40, 10
     t.resize 40, 10, cell_width: 8, cell_height: 16
     t.feed "\e[?1000h\e[?1006h"
 
-    # reflex counts a wheel delta downwards, so button 4 is a negative one
-    t.write_wheel R::WheelEvent.new(0, 0, 0, 0, -1, 0, 0)
+    # a wheel delta is in pixels and reflex counts it downwards, so a cell
+    # height upwards is one row, and one row up is button 4
+    t.write_wheel R::WheelEvent.new(0, 0, 0, 0, -16, 0, 0)
     assert_equal "\e[<64;1;1M\e[<64;1;1m", t.read_pending_input
 
-    t.write_wheel R::WheelEvent.new(0, 0, 0, 0, 1, 0, 0)
+    t.write_wheel R::WheelEvent.new(0, 0, 0, 0, 16, 0, 0)
+    assert_equal "\e[<65;1;1M\e[<65;1;1m", t.read_pending_input
+
+    # what does not add up to a whole row waits for the next delta rather
+    # than being dropped
+    t.write_wheel R::WheelEvent.new(0, 0, 0, 0, 8, 0, 0)
+    assert_equal '', t.read_pending_input
+
+    t.write_wheel R::WheelEvent.new(0, 0, 0, 0, 8, 0, 0)
     assert_equal "\e[<65;1;1M\e[<65;1;1m", t.read_pending_input
   end
 
@@ -516,7 +671,7 @@ class TestTerminal < Test::Unit::TestCase
     assert_equal 'あ', t.selected_text
     assert_equal(
       [['あ', true], ['いうえお', false]],
-      t.each_span.map {|x, y, w, str, fg, bg, flags|
+      t.each_span.map {|x, y, w, str, fg, bg, ul, flags|
         [str, (flags & T::SELECTED) != 0]})
   end
 

data/test/test_terminal_view.rb

@@ -12,7 +12,7 @@ class TestTerminalView < Test::Unit::TestCase
   # drag that would reach back to one
   def press(view, x, y, click_count: 1, modifiers: 0, button: Reflex::Pointer::MOUSE_LEFT)
     position = Reflex::Point.new(
-      x * view.font.width('M'), y * view.font.height.ceil)
+      x * view.font.width('M').ceil, y * view.font.height.ceil)
     Reflex::PointerEvent.new Reflex::Pointer.new(
       1, Reflex::Pointer::MOUSE | button,
       Reflex::Pointer::DOWN, position, modifiers, click_count, false, 0)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: reflex-terminal
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - xordog
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-08-04 00:00:00.000000000 Z
+date: 2026-11-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: xot
@@ -16,56 +16,56 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.4.0
+        version: 0.5.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.4.0
+        version: 0.5.0
 - !ruby/object:Gem::Dependency
   name: rucy
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.4.0
+        version: 0.5.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.4.0
+        version: 0.5.0
 - !ruby/object:Gem::Dependency
   name: rays
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.4.0
+        version: 0.5.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.4.0
+        version: 0.5.0
 - !ruby/object:Gem::Dependency
   name: reflexion
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.6.0
+        version: 0.7.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.6.0
+        version: 0.7.0
 description: Provides Reflex::Terminal, a headless terminal emulator model built on
   libghostty-vt, and Reflex::TerminalView, a View that renders it in the Reflex GUI
   toolkit.
@@ -85,10 +85,10 @@ files:
 - ".github/workflows/release-gem.yml"
 - ".github/workflows/tag.yml"
 - ".github/workflows/test.yml"
-- ".github/workflows/utils.rb"
 - CONTRIBUTING.md
 - ChangeLog.md
 - Gemfile
+- Gemfile.lock
 - LICENSE
 - README.md
 - Rakefile
@@ -141,7 +141,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.19
+rubygems_version: 3.5.22
 signing_key:
 specification_version: 4
 summary: A terminal emulator view for Reflex.

data/.github/workflows/utils.rb

@@ -1,127 +0,0 @@
-require 'shellwords'
-
-ALL_REPO        = 'xord/all'
-ALL_DIR         = '../all'
-ALL_FETCH_DEPTH = 100
-
-RENAMES = {reflex: 'reflexion'}
-
-def sh(cmd)
-  puts cmd
-  system cmd
-end
-
-def setup_dependencies(only: nil)
-  gemspec_path = `git ls-files`.lines(chomp: true).find {|l| l =~ /\.gemspec$/}
-  return unless gemspec_path
-
-  gemspec = File.read gemspec_path
-  name    = File.basename gemspec_path, '.gemspec'
-
-  exts = File.readlines('Rakefile')
-    .map {|l| l[%r|^\s*require\W+([\w\-\_]+)/extension\W+$|, 1]}
-    .compact
-    .reject {|ext| ext == name}
-  exts = exts & [only].flatten.map(&:to_s) if only
-  return if exts.empty?
-
-  unless setup_dependencies_via_monorepo(exts)
-    setup_dependencies_via_each_repo_by_version(gemspec, exts)
-  end
-
-  exts.each {|ext| sh %( cd ../#{ext} && rake ext )}
-end
-
-def setup_dependencies_via_monorepo(exts)
-  return false unless checkout_monorepo
-  exts.each {|ext| sh %( ln -snf all/#{ext} ../#{ext} )}
-  true
-end
-
-def checkout_monorepo()
-  uuid = `git log -1 --format=%B`[/^\[\[([0-9a-fA-F-]+)\]\]$/, 1]
-  return false unless uuid
-
-  commit = setup_monorepo uuid
-  return false unless commit
-
-  Dir.chdir(ALL_DIR) {sh %( git checkout -q #{commit} )}
-  true
-end
-
-def setup_monorepo(uuid)
-  unless File.directory? ALL_DIR
-    url = "https://github.com/#{ALL_REPO}.git"
-    sh %( git clone --no-tags --depth #{ALL_FETCH_DEPTH} #{url} #{ALL_DIR} )
-  end
-  loop do
-    commit = find_monorepo_commit uuid
-    return commit if commit
-
-    deepened = Dir.chdir ALL_DIR do
-      before = `git rev-list --count HEAD`.to_i
-      sh %( git fetch --deepen #{ALL_FETCH_DEPTH} )
-      `git rev-list --count HEAD`.to_i > before
-    end
-    return nil unless deepened
-  end
-end
-
-def find_monorepo_commit(uuid)
-  Dir.chdir ALL_DIR do
-    out = `git log origin/HEAD -F --grep="[[#{uuid}]]" --format=%H -1`.strip
-    out.empty? ? nil : out
-  end
-end
-
-def setup_dependencies_via_each_repo_by_version(gemspec, exts)
-  exts.each do |ext|
-    gem   = RENAMES[ext.to_sym].then {|s| s || ext}
-    ver   = gemspec[/add_dependency.*['"]#{gem}['"].*['"]\s*~>\s*([\d\.]+)\s*['"]/, 1]
-    opts  = '-c advice.detachedHead=false --depth 1'
-    clone = "git clone #{opts} https://github.com/xord/#{ext}.git ../#{ext}"
-
-    # 'rake subtree:push' pushes all subrepos, so cloning by new tag
-    # often fails before tagging each new tag
-    sh %( #{clone} --branch v#{ver} || #{clone} )
-  end
-end
-
-def tag_versions()
-  changes = changelogs
-  tags    = `git tag`.lines chomp: true
-  vers    = `git log --oneline ./VERSION`
-    .lines(chomp: true)
-    .map {|line| line.split.first[/^\w+$/]}
-    .map {|sha| [`git cat-file -p #{sha}:./VERSION 2>/dev/null`[/[\d\.]+/], sha]}
-    .select {|ver, sha| ver && sha}
-    .reverse
-    .to_h
-
-  vers.to_a.reverse.each do |ver, sha|
-    tag = "v#{ver}"
-    break if tags.include?(tag)
-    sh %( git tag -a -m \"#{changes[tag]&.gsub '"', '\\"'}\" #{tag} #{sha} )
-  end
-end
-
-def release(*paths)
-  tag   = ENV['GITHUB_REF']&.sub(%r|^refs/tags/|, '') || raise('GITHUB_REF tag not set')
-  notes = (changelogs[tag] || '').shellescape
-  paths = paths.flatten.join ' '
-
-  sh(%( gh release create #{tag} #{paths} --notes #{notes} )) ||
-    sh(%( gh release upload #{tag} #{paths} --clobber )) ||
-    raise('failed to upload to releases')
-end
-
-def changelogs()
-  File.read('ChangeLog.md')
-    .split(/^\s*##\s*\[\s*(v[\d\.]+)\s*\].*$/)
-    .slice(1..)
-    .each_slice(2)
-    .to_h
-    .transform_values(&:strip!)
-rescue Errno::ENOENT
-  raise 'failed to get changelogs'
-end