hyperlist 1.5.2 → 1.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ec123fe286a3c475f76868ed8d0cdd1a512f7323c6da8d9446d2ea7e3913ce61
-  data.tar.gz: 637a405887c8725cd229ba0dbd8bfa0d0f75cffa787f336a59477a32a70b1669
+  metadata.gz: 014e81876165c457903e5f20e8f848f2c59fce0d2672e700ff909873c03c260a
+  data.tar.gz: c60b73c642984f70ba2bfdcceb7ca6a9bc501c46071cb362d9e9343778cd8f40
 SHA512:
-  metadata.gz: c1ec3ebc57c928ab5c583da3ab2663cbaf73da09e36818f14e0973f3392583ebb5dc4ad1ee543f8263b386709677b70b73227b71c8145738f5afeee14e7a6af4
-  data.tar.gz: 8d2ff0119d45decfba5fbef08d96d19ebf92f63d0ce33fe35350a3a53cd92fbb94cc845fe85a951d746c374b87b2932c50f5bd54623b953edab162e8eee901c8
+  metadata.gz: 37ba0da349a30af46424cc374ece24e315c32a22ee48bf81f4893c43e20cdf18f42ec71c3b3fe123688f9b97597a29e8aa583884cceb361d44583645546aaf25
+  data.tar.gz: 5a8737705ad4d231e6ce1a8a1b8f440cf8b0f3c2ffa7586052dc64be5a55d8bc4491ed721b07adb192e6674f0560a9ac35a6a067ed27831b200066b786456081

data/CHANGELOG.md

@@ -2,11 +2,41 @@
 
 All notable changes to the HyperList Ruby TUI will be documented in this file.
 
+## [1.7.0] - 2025-09-18
+
+### Added
+- **Checkbox removal feature**
+  - **C-X key**: Remove checkboxes from items
+  - Removes all checkbox patterns: `[ ]`, `[X]`, `[x]`, `[O]`, `[-]`, `[_]`
+  - Also removes associated timestamps (YYYY-MM-DD HH.MM: format)
+  - Provides feedback messages for successful removal or no checkbox found
+  - Added to help documentation under SPECIAL FEATURES
+  - Complements existing v/V checkbox toggle functionality
+
+### Enhanced
+- **Cross-parent movement improvements**
+  - C-UP/C-DOWN now respect visibility principle (move only item if uncollapsed, item+children if collapsed)
+  - Added orphaned children reunification logic
+  - Items moved into collapsed areas automatically unfold destination
+  - Moved items are guaranteed to remain visible (safety net protection)
+  - Single-step movement: C-DOWN moves exactly one position down, not to end of descendants
+
+## [1.6.0] - 2025-09-18
+
+### BREAKING CHANGES
+- **Complete reassignment of arrow key functionality**
+  - **RIGHT key**: Now uncollapses items (if collapsed)
+  - **LEFT key**: Now collapses items (if they have children)
+  - **TAB key**: Takes over old RIGHT key functionality (indent right)
+  - **S-TAB key**: Takes over old LEFT key functionality (indent left)
+  - This provides more intuitive navigation where arrow keys control visibility and TAB keys control indentation
+  - Updated help documentation to reflect new key mappings
+
 ## [1.5.2] - 2025-09-18
 
 ### Enhanced
 - **Smart movement behavior for collapsed items**
-  - LEFT/RIGHT arrow keys now move collapsed trees as a unit when item is folded
+  - LEFT/RIGHT arrow keys move collapsed trees as a unit when item is folded
   - Uncollapsed items move individually (only the current item)
   - Maintains "move what's visible" principle for intuitive navigation
   - Works in both normal and split-view modes

data/hyperlist

@@ -72,7 +72,7 @@ class HyperListApp
   include Rcurses::Input
   include Rcurses::Cursor
   
-  VERSION = "1.5.1"
+  VERSION = "1.7.0"
   
   def initialize(filename = nil)
     @filename = filename ? File.expand_path(filename) : nil
@@ -1733,7 +1733,61 @@ class HyperListApp
       end
     end
   end
-  
+
+  def collapse_item
+    if @split_view && @active_pane == :split
+      # Handle collapse in split pane
+      visible_items = get_visible_split_items
+      return if @split_current >= visible_items.length
+
+      item = visible_items[@split_current]
+      real_idx = @split_items.index(item)
+
+      if real_idx && has_children_in_array?(real_idx, @split_items) && !item["fold"]
+        item["fold"] = true
+      end
+    else
+      # Handle collapse in main pane
+      visible = get_visible_items
+      return if @current >= visible.length
+
+      item = visible[@current]
+      real_idx = get_real_index(item)
+
+      if real_idx && has_children?(real_idx, @items) && !@items[real_idx]["fold"]
+        @items[real_idx]["fold"] = true
+        record_last_action(:toggle_fold, nil)
+      end
+    end
+  end
+
+  def uncollapse_item
+    if @split_view && @active_pane == :split
+      # Handle uncollapse in split pane
+      visible_items = get_visible_split_items
+      return if @split_current >= visible_items.length
+
+      item = visible_items[@split_current]
+      real_idx = @split_items.index(item)
+
+      if real_idx && has_children_in_array?(real_idx, @split_items) && item["fold"]
+        item["fold"] = false
+      end
+    else
+      # Handle uncollapse in main pane
+      visible = get_visible_items
+      return if @current >= visible.length
+
+      item = visible[@current]
+      real_idx = get_real_index(item)
+
+      if real_idx && has_children?(real_idx, @items) && @items[real_idx]["fold"]
+        @items[real_idx]["fold"] = false
+        record_last_action(:toggle_fold, nil)
+      end
+    end
+  end
+
   def move_up
     if @presentation_mode
       # In presentation mode, we need to handle navigation differently
@@ -2578,26 +2632,132 @@ class HyperListApp
     @message = "Pasted #{@clipboard.length} item(s)"
     record_last_action(:paste, nil)
   end
-  
+
+  def calculate_level_for_position(target_real_idx)
+    # Calculate appropriate level for an item at target_real_idx position
+    # based on surrounding items in the @items array
+
+    # If at the beginning, level 0
+    return 0 if target_real_idx == 0
+
+    # Look at the previous item
+    prev_item = @items[target_real_idx - 1]
+    prev_level = prev_item["level"]
+
+    # Look at the next item if it exists
+    if target_real_idx < @items.length
+      next_item = @items[target_real_idx]
+      next_level = next_item["level"]
+
+      # If next item is at same or lower level than previous,
+      # we can be at the same level as previous (sibling)
+      if next_level <= prev_level
+        return prev_level
+      else
+        # Next item is deeper, so we could be parent (prev_level)
+        # or child (prev_level + 1), choose to be sibling of previous
+        return prev_level
+      end
+    else
+      # At the end, can be sibling of previous item
+      return prev_level
+    end
+  end
+
+  def find_orphaned_children(item_text, target_real_idx)
+    # Look for children that might belong to the item being moved
+    orphaned_children = []
+
+    # Search from target position onwards for potential children
+    # Look for items at level 2 or higher that could be children
+    (target_real_idx...@items.length).each do |i|
+      item_level = @items[i]["level"]
+
+      # Stop if we hit an item at level 0 or 1 (new parent/sibling)
+      break if item_level <= 1
+
+      # If we find items at level 2+, they could be orphaned children
+      # (In the example: Subtask A1.1, A1.2 are level 2)
+      if item_level >= 2
+        orphaned_children << i
+      else
+        break  # Hit a sibling, stop looking
+      end
+    end
+
+    orphaned_children
+  end
+
+  def ensure_destination_visible(target_real_idx, item_level)
+    # Unfold any collapsed areas that would hide an item at target_real_idx with item_level
+    return if target_real_idx >= @items.length || target_real_idx < 0
+
+    # Walk backwards from the target position to find potential ancestor items
+    (target_real_idx - 1).downto(0) do |i|
+      item = @items[i]
+
+      # If this item is at a higher level (lower number) than our item will be, it's a potential ancestor
+      if item["level"] < item_level
+        # If this ancestor is folded, unfold it to make the destination visible
+        if item["fold"] && has_children?(i, @items)
+          item["fold"] = false
+        end
+
+        # Update item_level to continue searching for higher ancestors
+        item_level = item["level"]
+
+        # If we reach level 0, we're done
+        break if item_level == 0
+      end
+    end
+  end
+
+  def force_item_visible(target_real_idx)
+    # Absolutely ensure the item at target_real_idx is visible - last resort safety net
+    return if target_real_idx >= @items.length || target_real_idx < 0
+
+    target_item = @items[target_real_idx]
+    target_level = target_item["level"]
+
+    # Walk backwards and unfold ALL ancestors, no matter what
+    (target_real_idx - 1).downto(0) do |i|
+      item = @items[i]
+
+      # If this item could be an ancestor (higher in hierarchy)
+      if item["level"] < target_level
+        # Force unfold it, regardless of whether it has children
+        item["fold"] = false if item.has_key?("fold")
+
+        # Update target_level to continue searching
+        target_level = item["level"]
+
+        # Continue until we reach level 0
+        break if target_level == 0
+      end
+    end
+
+    # Force a cache clear to ensure visibility updates
+    clear_cache if respond_to?(:clear_cache)
+  end
+
   def move_item_up(with_children = false)
     visible = get_visible_items
     return if @current >= visible.length || @current == 0
-    
+
     save_undo_state  # Save state before modification
-    
-    item = visible[@current]
-    real_idx = get_real_index(item)
-    
-    # Can't move if already at the beginning
-    return if real_idx == 0
-    
-    # Collect item(s) to move
-    items_to_move = [item]
-    
+
+    current_item = visible[@current]
+    current_real_idx = get_real_index(current_item)
+
+    # Get the previous visible item
+    prev_visible_item = visible[@current - 1]
+    prev_real_idx = get_real_index(prev_visible_item)
+
+    # Collect items to move (current item + children if requested)
+    items_to_move = [current_item]
     if with_children
-      # Collect all children
-      level = item["level"]
-      ((real_idx + 1)...@items.length).each do |i|
+      level = current_item["level"]
+      ((current_real_idx + 1)...@items.length).each do |i|
         if @items[i]["level"] > level
           items_to_move << @items[i]
         else
@@ -2605,46 +2765,42 @@ class HyperListApp
         end
       end
     end
-    
-    # Find the previous sibling at the same level
-    target_level = item["level"]
-    target_idx = nil
-    
-    # Search backwards for a sibling at the same level
-    (real_idx - 1).downto(0) do |i|
-      if @items[i]["level"] == target_level
-        target_idx = i
-        break
-      elsif @items[i]["level"] < target_level
-        # Hit a parent, can't move up
-        return
-      end
+
+    # Calculate what level the moved item should have at the target position
+    new_level = calculate_level_for_position(prev_real_idx)
+    level_diff = new_level - items_to_move.first["level"]
+
+    # Unfold destination area BEFORE moving if needed
+    ensure_destination_visible(prev_real_idx, new_level)
+
+    # Remove the items to move
+    items_to_move.length.times { @items.delete_at(current_real_idx) }
+
+    # Adjust target position since we removed items after it
+    adjusted_target = prev_real_idx
+    if prev_real_idx > current_real_idx
+      adjusted_target -= items_to_move.length
     end
-    
-    # Can't move if no sibling found
-    return if target_idx.nil?
-    
-    # Remember the first item we're moving (to track it)
-    first_moved_item = items_to_move.first
-    
-    # Remove items from their current position
-    items_to_move.length.times { @items.delete_at(real_idx) }
-    
-    # Insert before the target sibling
-    items_to_move.reverse.each do |item_to_move|
-      @items.insert(target_idx, item_to_move)
+
+    # Adjust levels of moved items
+    items_to_move.each do |moved_item|
+      moved_item["level"] += level_diff
+      moved_item["level"] = [moved_item["level"], 0].max  # Ensure level doesn't go negative
     end
-    
-    # Update cursor position to follow the moved item
-    # The moved item is now at position target_idx in @items
-    # Find this position in the visible list
+
+    # Insert items at target position
+    items_to_move.each_with_index do |item_to_move, idx|
+      @items.insert(adjusted_target + idx, item_to_move)
+    end
+
+    # FORCE the moved item to be visible (safety net)
+    force_item_visible(adjusted_target)
+
+    # Update cursor to follow the moved item
     new_visible = get_visible_items
-    new_item_idx = new_visible.find_index { |v| v["_real_index"] == target_idx }
+    new_item_idx = new_visible.find_index { |v| get_real_index(v) == adjusted_target }
     @current = new_item_idx if new_item_idx
-    
-    # Renumber siblings at the moved item's level
-    renumber_siblings(first_moved_item["level"])
-    
+
     @modified = true
     @message = "Moved #{items_to_move.length} item(s) up"
     record_last_action(:move_item_up, with_children)
@@ -2653,81 +2809,71 @@ class HyperListApp
   def move_item_down(with_children = false)
     visible = get_visible_items
     return if @current >= visible.length - 1
-    
+
     save_undo_state  # Save state before modification
-    
-    item = visible[@current]
-    real_idx = get_real_index(item)
-    
-    # Collect item(s) to move
-    items_to_move = [item]
-    last_idx = real_idx
-    
+
+    current_item = visible[@current]
+    current_real_idx = get_real_index(current_item)
+
+    # Get the next visible item
+    next_visible_item = visible[@current + 1]
+    next_real_idx = get_real_index(next_visible_item)
+
+    # Collect items to move (current item + children if requested)
+    items_to_move = [current_item]
     if with_children
-      # Collect all children
-      level = item["level"]
-      ((real_idx + 1)...@items.length).each do |i|
+      level = current_item["level"]
+      ((current_real_idx + 1)...@items.length).each do |i|
         if @items[i]["level"] > level
           items_to_move << @items[i]
-          last_idx = i
         else
           break
         end
       end
     end
-    
-    # Find the next sibling at the same level
-    target_level = item["level"]
-    target_idx = nil
-    next_sibling_end = nil
-    
-    # Search forward for a sibling at the same level
-    ((last_idx + 1)...@items.length).each do |i|
-      if @items[i]["level"] == target_level
-        # Found next sibling, now find where it ends (including its children)
-        next_sibling_end = i
-        ((i + 1)...@items.length).each do |j|
-          if @items[j]["level"] > target_level
-            next_sibling_end = j
-          else
-            break
-          end
-        end
-        target_idx = next_sibling_end + 1
-        break
-      elsif @items[i]["level"] < target_level
-        # Hit a parent level, can't move down
-        return
-      end
+
+    # Target is immediately after the next visible item (not after its children)
+    target_real_idx = next_real_idx + 1
+
+    # Check if there are orphaned children at the target position
+    # If so, position before them to reunite
+    orphaned_children = find_orphaned_children(current_item["text"], target_real_idx)
+    if !orphaned_children.empty?
+      target_real_idx = orphaned_children.first
     end
-    
-    # Can't move if no sibling found
-    return if target_idx.nil?
-    
-    # Remember the first item we're moving (to track it)
-    first_moved_item = items_to_move.first
-    
-    # Remove items from their current position
-    items_to_move.length.times { @items.delete_at(real_idx) }
-    
-    # Adjust target index since we removed items
-    target_idx -= items_to_move.length
-    
-    # Insert after the target sibling and its children
+
+    # Calculate what level the moved item should have at the target position
+    new_level = calculate_level_for_position(target_real_idx)
+    level_diff = new_level - items_to_move.first["level"]
+
+    # Unfold destination area BEFORE moving if needed
+    ensure_destination_visible(target_real_idx, new_level)
+
+    # Remove the items to move
+    items_to_move.length.times { @items.delete_at(current_real_idx) }
+
+    # Adjust target position since we removed items before it
+    adjusted_target = target_real_idx - items_to_move.length
+
+    # Adjust levels of moved items
+    items_to_move.each do |moved_item|
+      moved_item["level"] += level_diff
+      moved_item["level"] = [moved_item["level"], 0].max  # Ensure level doesn't go negative
+    end
+
+    # Insert items at target position
     items_to_move.each_with_index do |item_to_move, idx|
-      @items.insert(target_idx + idx, item_to_move)
+      @items.insert(adjusted_target + idx, item_to_move)
     end
-    
-    # Update cursor position to follow the moved item
-    # The moved item is now at position target_idx in @items
-    # Find this position in the visible list
+
+    # FORCE the moved item to be visible (safety net)
+    force_item_visible(adjusted_target)
+
+    # Update cursor to follow the moved item
     new_visible = get_visible_items
-    new_item_idx = new_visible.find_index { |v| v["_real_index"] == target_idx }
+    new_item_idx = new_visible.find_index { |v| get_real_index(v) == adjusted_target }
     @current = new_item_idx if new_item_idx
-    
-    # Renumber siblings at the moved item's level
-    renumber_siblings(first_moved_item["level"])
-    
+
     @modified = true
     @message = "Moved #{items_to_move.length} item(s) down"
     record_last_action(:move_item_down, with_children)
@@ -2876,7 +3022,35 @@ class HyperListApp
     @modified = true
     record_last_action(:toggle_checkbox_with_date, nil)
   end
-  
+
+  def remove_checkbox
+    visible = get_visible_items
+    return if @current >= visible.length
+
+    save_undo_state  # Save state before modification
+
+    item = visible[@current]
+    real_idx = get_real_index(item)
+    text = @items[real_idx]["text"]
+
+    # Remove checkbox patterns: [ ], [X], [x], [O], [-], [_]
+    if text =~ /^\[[ X_Ox-]\]/
+      # Remove the checkbox and any following space
+      text = text.sub(/^\[[ X_Ox-]\]\s*/, '')
+
+      # Also remove any timestamp that might be associated with checkbox
+      # Format: YYYY-MM-DD HH.MM: or similar
+      text = text.sub(/^\d{4}-\d{2}-\d{2} \d{2}\.\d{2}:\s*/, '')
+
+      @items[real_idx]["text"] = text
+      @modified = true
+      @message = "Removed checkbox"
+      record_last_action(:remove_checkbox, nil)
+    else
+      @message = "No checkbox to remove"
+    end
+  end
+
   def search_forward
     @mode = :search
     @search = @footer.ask("Search: ", @search || "")
@@ -3013,12 +3187,13 @@ class HyperListApp
     help_lines << help_line("#{"u".fg("10")}", "Undo", "#{".".fg("10")}", "Repeat last action")
     help_lines << help_line("#{"r".fg("10")}" + ", ".fg("10") + "#{"C-R".fg("10")}", "Redo")
     help_lines << help_line("#{"S-UP".fg("10")}", "Move item up", "#{"S-DOWN".fg("10")}", "Move item down")
-    help_lines << help_line("#{"C-UP".fg("10")}", "Move item&descendants up", "#{"C-DOWN".fg("10")}", "Move item&descendants down")
+    help_lines << help_line("#{"C-UP".fg("10")}", "Move up in visible list", "#{"C-DOWN".fg("10")}", "Move down in visible list")
+    help_lines << help_line("#{"→".fg("10")}", "Uncollapse item", "#{"←".fg("10")}", "Collapse item")
     help_lines << help_line("#{"Tab".fg("10")}", "Indent item+kids", "#{"S-Tab".fg("10")}", "Unindent item+kids")
-    help_lines << help_line("#{"→".fg("10")}", "Indent item only", "#{"←".fg("10")}", "Unindent item only")
     help_lines << ""
     help_lines << "#{"SPECIAL FEATURES".fg("14")}"
     help_lines << help_line("#{"v".fg("10")}", "Toggle checkbox", "#{"V".fg("10")}", "Checkbox with date")
+    help_lines << help_line("#{"C-X".fg("10")}", "Remove checkbox", "", "")
     help_lines << help_line("#{"C-E".fg("10")}", "Encrypt/decrypt line", "#{"C-U".fg("10")}", "Toggle State/Trans underline")
     help_lines << help_line("#{"P".fg("10")}", "Presentation mode", "#{"Tab/S-Tab".fg("10")}", "Next/prev sibling (in P)")
     help_lines << help_line("#{"Ma".fg("10")}", "Record macro 'a'", "#{"@a".fg("10")}", "Play macro 'a'")
@@ -4894,34 +5069,30 @@ class HyperListApp
       toggle_checkbox
     when "V"
       toggle_checkbox_with_date
+    when "C-X"  # Ctrl-Shift-X for remove checkbox
+      remove_checkbox
     when "TAB"
-      if @split_view && @active_pane == :split
-        indent_split_right(true)  # with children
-      else
-        indent_right(true)  # with children
-      end
-    when "S-TAB"
-      if @split_view && @active_pane == :split
-        indent_split_left(true)  # with children
-      else
-        indent_left(true)  # with children
-      end
-    when "RIGHT"
-      # Move collapsed trees as a unit, but only the item if uncollapsed
+      # Indent with move conditions (moved from RIGHT key)
       should_move_children = should_move_with_children?
       if @split_view && @active_pane == :split
         indent_split_right(should_move_children)
       else
         indent_right(should_move_children)
       end
-    when "LEFT"
-      # Move collapsed trees as a unit, but only the item if uncollapsed
+    when "S-TAB"
+      # Unindent with move conditions (moved from LEFT key)
       should_move_children = should_move_with_children?
       if @split_view && @active_pane == :split
         indent_split_left(should_move_children)
       else
         indent_left(should_move_children)
       end
+    when "RIGHT"
+      # Uncollapse item if it is collapsed
+      uncollapse_item
+    when "LEFT"
+      # Collapse item if it has children
+      collapse_item
     when " "
       toggle_fold
     when "u"
@@ -5709,21 +5880,11 @@ class HyperListApp
         when "l"
           go_to_first_child
         when "LEFT"
-          # Move collapsed trees as a unit, but only the item if uncollapsed
-          should_move_children = should_move_with_children?
-          if @split_view && @active_pane == :split
-            indent_split_left(should_move_children)
-          else
-            indent_left(should_move_children)
-          end
+          # Collapse item if it has children
+          collapse_item
         when "RIGHT"
-          # Move collapsed trees as a unit, but only the item if uncollapsed
-          should_move_children = should_move_with_children?
-          if @split_view && @active_pane == :split
-            indent_split_right(should_move_children)
-          else
-            indent_right(should_move_children)
-          end
+          # Uncollapse item if it is collapsed
+          uncollapse_item
         when "PgUP"  # Page Up
           page_up
         when "PgDOWN"  # Page Down
@@ -5857,22 +6018,23 @@ class HyperListApp
           move_item_up(false)
         when "S-DOWN"  # Move item down
           move_item_down(false)
-        when "C-UP"  # Move item and descendants up
-          move_item_up(true)
-        when "C-DOWN"  # Move item and descendants down
-          move_item_down(true)
-        when "C-K"  # Alternative: Move item and descendants up (for terminals that intercept C-UP)
-          move_item_up(true)
+        when "C-UP"  # Move up in visible list (with children only if collapsed)
+          move_item_up(should_move_with_children?)
+        when "C-DOWN"  # Move down in visible list (with children only if collapsed)
+          move_item_down(should_move_with_children?)
+        when "C-K"  # Alternative: Move up in visible list (for terminals that intercept C-UP)
+          move_item_up(should_move_with_children?)
         when "TAB"
           if @presentation_mode
             # In presentation mode, Tab goes to next sibling
             jump_to_next_sibling
           else
-            # Normal mode: Indent with all children
+            # Normal mode: Indent with move conditions (moved from RIGHT key)
+            should_move_children = should_move_with_children?
             if @split_view && @active_pane == :split
-              indent_split_right(true)
+              indent_split_right(should_move_children)
             else
-              indent_right(true)
+              indent_right(should_move_children)
             end
           end
         when "S-TAB"  # Shift-Tab
@@ -5880,11 +6042,12 @@ class HyperListApp
             # In presentation mode, Shift-Tab goes to previous sibling
             jump_to_prev_sibling
           else
-            # Normal mode: Unindent with all children
+            # Normal mode: Unindent with move conditions (moved from LEFT key)
+            should_move_children = should_move_with_children?
             if @split_view && @active_pane == :split
-              indent_split_left(true)
+              indent_split_left(should_move_children)
             else
-              indent_left(true)
+              indent_left(should_move_children)
             end
           end
         when "u"
@@ -5895,6 +6058,8 @@ class HyperListApp
           toggle_checkbox
         when "V"
           toggle_checkbox_with_date
+        when "C-X"  # Ctrl-Shift-X for remove checkbox
+          remove_checkbox
         when "."
           repeat_last_action
         when "/"

data/hyperlist.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |spec|
   spec.name          = "hyperlist"
-  spec.version       = "1.5.2"
+  spec.version       = "1.7.0"
   spec.authors       = ["Geir Isene"]
   spec.email         = ["g@isene.com"]
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hyperlist
 version: !ruby/object:Gem::Version
-  version: 1.5.2
+  version: 1.7.0
 platform: ruby
 authors:
 - Geir Isene
 autorequire:
 bindir: "."
 cert_chain: []
-date: 2025-09-18 00:00:00.000000000 Z
+date: 2025-09-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rcurses