ruvim 0.1.0 → 0.3.0

data/lib/ruvim/editor.rb

@@ -1,22 +1,82 @@
+# frozen_string_literal: true
+
 module RuVim
   class Editor
     OPTION_DEFS = {
       "number" => { default_scope: :window, type: :bool, default: false },
       "relativenumber" => { default_scope: :window, type: :bool, default: false },
+      "wrap" => { default_scope: :window, type: :bool, default: true },
+      "linebreak" => { default_scope: :window, type: :bool, default: false },
+      "breakindent" => { default_scope: :window, type: :bool, default: false },
+      "cursorline" => { default_scope: :window, type: :bool, default: false },
+      "scrolloff" => { default_scope: :window, type: :int, default: 0 },
+      "sidescrolloff" => { default_scope: :window, type: :int, default: 0 },
+      "numberwidth" => { default_scope: :window, type: :int, default: 4 },
+      "colorcolumn" => { default_scope: :window, type: :string, default: nil },
+      "signcolumn" => { default_scope: :window, type: :string, default: "auto" },
+      "list" => { default_scope: :window, type: :bool, default: false },
+      "listchars" => { default_scope: :window, type: :string, default: "tab:>-,trail:-,nbsp:+" },
+      "showbreak" => { default_scope: :window, type: :string, default: ">" },
+      "showmatch" => { default_scope: :global, type: :bool, default: false },
+      "matchtime" => { default_scope: :global, type: :int, default: 5 },
+      "whichwrap" => { default_scope: :global, type: :string, default: "" },
+      "virtualedit" => { default_scope: :global, type: :string, default: "" },
       "ignorecase" => { default_scope: :global, type: :bool, default: false },
       "smartcase" => { default_scope: :global, type: :bool, default: false },
       "hlsearch" => { default_scope: :global, type: :bool, default: true },
+      "incsearch" => { default_scope: :global, type: :bool, default: false },
+      "splitbelow" => { default_scope: :global, type: :bool, default: false },
+      "splitright" => { default_scope: :global, type: :bool, default: false },
+      "hidden" => { default_scope: :global, type: :bool, default: false },
+      "autowrite" => { default_scope: :global, type: :bool, default: false },
+      "clipboard" => { default_scope: :global, type: :string, default: "" },
+      "timeoutlen" => { default_scope: :global, type: :int, default: 1000 },
+      "ttimeoutlen" => { default_scope: :global, type: :int, default: 50 },
+      "backspace" => { default_scope: :global, type: :string, default: "indent,eol,start" },
+      "completeopt" => { default_scope: :global, type: :string, default: "menu,menuone,noselect" },
+      "pumheight" => { default_scope: :global, type: :int, default: 10 },
+      "wildmode" => { default_scope: :global, type: :string, default: "full" },
+      "wildignore" => { default_scope: :global, type: :string, default: "" },
+      "wildignorecase" => { default_scope: :global, type: :bool, default: false },
+      "wildmenu" => { default_scope: :global, type: :bool, default: false },
+      "termguicolors" => { default_scope: :global, type: :bool, default: false },
+      "path" => { default_scope: :buffer, type: :string, default: nil },
+      "suffixesadd" => { default_scope: :buffer, type: :string, default: nil },
+      "textwidth" => { default_scope: :buffer, type: :int, default: 0 },
+      "formatoptions" => { default_scope: :buffer, type: :string, default: nil },
+      "expandtab" => { default_scope: :buffer, type: :bool, default: false },
+      "shiftwidth" => { default_scope: :buffer, type: :int, default: 2 },
+      "softtabstop" => { default_scope: :buffer, type: :int, default: 0 },
+      "autoindent" => { default_scope: :buffer, type: :bool, default: true },
+      "smartindent" => { default_scope: :buffer, type: :bool, default: true },
+      "iskeyword" => { default_scope: :buffer, type: :string, default: nil },
       "tabstop" => { default_scope: :buffer, type: :int, default: 2 },
-      "filetype" => { default_scope: :buffer, type: :string, default: nil }
+      "filetype" => { default_scope: :buffer, type: :string, default: nil },
+      "onsavehook" => { default_scope: :buffer, type: :bool, default: true },
+      "grepprg" => { default_scope: :global, type: :string, default: "grep -nH" },
+      "grepformat" => { default_scope: :global, type: :string, default: "%f:%l:%m" }
     }.freeze
-
-    attr_reader :buffers, :windows
-    attr_accessor :current_window_id, :mode, :message, :pending_count, :alternate_buffer_id, :window_layout, :restricted_mode
+    SHEBANG_FILETYPE_RULES = [
+      [/\Aruby(?:\d+(?:\.\d+)*)?\z/, "ruby"],
+      [/\Apython(?:\d+(?:\.\d+)*)?\z/, "python"],
+      ["node", "javascript"],
+      ["nodejs", "javascript"],
+      ["deno", "javascript"],
+      ["bash", "sh"],
+      ["sh", "sh"],
+      ["zsh", "sh"],
+      ["ksh", "sh"],
+      ["dash", "sh"],
+      [/\Aperl(?:\d+(?:\.\d+)*)?\z/, "perl"]
+    ].freeze
+
+    attr_reader :buffers, :windows, :layout_tree
+    attr_accessor :current_window_id, :mode, :message, :pending_count, :alternate_buffer_id, :restricted_mode, :current_window_view_height_hint, :stdin_stream_stop_handler, :open_path_handler, :keymap_manager, :app_action_handler
 
     def initialize
       @buffers = {}
       @windows = {}
-      @window_order = []
+      @layout_tree = nil
       @tabpages = []
       @current_tabpage_index = nil
       @next_tabpage_id = 1
@@ -26,12 +86,17 @@ module RuVim
       @current_window_id = nil
       @alternate_buffer_id = nil
       @mode = :normal
-      @window_layout = :single
       @message = ""
       @message_kind = :info
+      @message_deadline = nil
       @pending_count = nil
       @restricted_mode = false
+      @current_window_view_height_hint = 1
       @running = true
+      @stdin_stream_stop_handler = nil
+      @open_path_handler = nil
+      @keymap_manager = nil
+      @app_action_handler = nil
       @global_options = default_global_options
       @command_line = CommandLine.new
       @last_search = nil
@@ -45,8 +110,12 @@ module RuVim
       @macros = {}
       @macro_recording = nil
       @visual_state = nil
+      @rich_state = nil
       @quickfix_list = { items: [], index: nil }
       @location_lists = Hash.new { |h, k| h[k] = { items: [], index: nil } }
+      @arglist = []
+      @arglist_index = 0
+      @hit_enter_lines = nil
     end
 
     def running?
@@ -97,6 +166,22 @@ module RuVim
       @buffers.fetch(current_window.buffer_id)
     end
 
+    def stdin_stream_stop_or_cancel!
+      handler = @stdin_stream_stop_handler
+      return false unless handler
+
+      handler.call
+      true
+    end
+
+    def invoke_app_action(name, **kwargs)
+      handler = @app_action_handler
+      return false unless handler
+
+      handler.call(name.to_sym, **kwargs)
+      true
+    end
+
     def option_def(name)
       OPTION_DEFS[name.to_s]
     end
@@ -169,7 +254,7 @@ module RuVim
       base = File.basename(p)
       return "ruby" if %w[Gemfile Rakefile Guardfile].include?(base)
 
-      {
+      ext_ft = {
         ".rb" => "ruby",
         ".rake" => "ruby",
         ".ru" => "ruby",
@@ -187,8 +272,16 @@ module RuVim
         ".txt" => "text",
         ".html" => "html",
         ".css" => "css",
-        ".sh" => "sh"
+        ".sh" => "sh",
+        ".tsv" => "tsv",
+        ".csv" => "csv",
+        ".scm" => "scheme",
+        ".ss" => "scheme",
+        ".sld" => "scheme"
       }[File.extname(base).downcase]
+      return ext_ft if ext_ft
+
+      detect_filetype_from_shebang(p)
     end
 
     def registers
@@ -201,6 +294,12 @@ module RuVim
 
       payload = write_register_payload(key, text: text.to_s, type: type.to_sym)
       write_clipboard_register(key, payload)
+      if key == "\""
+        if (default_clip = clipboard_default_register_key)
+          mirror = write_register_payload(default_clip, text: payload[:text], type: payload[:type])
+          write_clipboard_register(default_clip, mirror)
+        end
+      end
       @registers["\""] = payload unless key == "\""
       payload
     end
@@ -225,6 +324,14 @@ module RuVim
 
     def get_register(name = "\"")
       key = name.to_s.downcase
+      if key == "\""
+        if (default_clip = clipboard_default_register_key)
+          if (payload = read_clipboard_register(default_clip))
+            @registers["\""] = dup_register_payload(payload)
+            return @registers["\""]
+          end
+        end
+      end
       return read_clipboard_register(key) if clipboard_register?(key)
 
       @registers[key]
@@ -423,6 +530,53 @@ module RuVim
       end
     end
 
+    def rich_state
+      @rich_state
+    end
+
+    def rich_mode?
+      @mode == :rich
+    end
+
+    def enter_rich_mode(format:, delimiter:)
+      @mode = :rich
+      @pending_count = nil
+      @rich_state = { format: format, delimiter: delimiter }
+    end
+
+    def exit_rich_mode
+      @rich_state = nil
+      enter_normal_mode
+    end
+
+    def hit_enter_active?
+      @mode == :hit_enter
+    end
+
+    def hit_enter_lines
+      @hit_enter_lines
+    end
+
+    def enter_hit_enter_mode(lines)
+      @mode = :hit_enter
+      @hit_enter_lines = Array(lines)
+      @pending_count = nil
+    end
+
+    def exit_hit_enter_mode
+      @hit_enter_lines = nil
+      enter_normal_mode
+    end
+
+    def echo_multiline(lines)
+      lines = Array(lines)
+      if lines.length <= 1
+        echo(lines.first.to_s)
+      else
+        enter_hit_enter_mode(lines)
+      end
+    end
+
     def add_empty_buffer(path: nil)
       id = next_buffer_id
       buffer = Buffer.new(id:, path:)
@@ -434,7 +588,7 @@ module RuVim
     def add_virtual_buffer(kind:, name:, lines:, filetype: nil, readonly: true, modifiable: false)
       id = next_buffer_id
       buffer = Buffer.new(id:, lines:, kind:, name:, readonly:, modifiable:)
-      buffer.options["filetype"] = filetype if filetype
+      assign_filetype(buffer, filetype) if filetype
       @buffers[id] = buffer
       buffer
     end
@@ -451,22 +605,40 @@ module RuVim
       id = next_window_id
       window = Window.new(id:, buffer_id:)
       @windows[id] = window
-      @window_order << id
+      leaf = { type: :window, id: id }
+      if @layout_tree.nil?
+        @layout_tree = leaf
+      else
+        # Append as sibling — used for initial bootstrap only
+        if @layout_tree[:type] == :window
+          @layout_tree = { type: :hsplit, children: [@layout_tree, leaf] }
+        else
+          @layout_tree[:children] << leaf
+        end
+      end
       @current_window_id ||= id
       ensure_initial_tabpage!
       save_current_tabpage_state! unless @suspend_tab_autosave
       window
     end
 
-    def split_current_window(layout: :horizontal)
+    def split_current_window(layout: :horizontal, place: :after)
       save_current_tabpage_state! unless @suspend_tab_autosave
       src = current_window
-      win = add_window(buffer_id: src.buffer_id)
+      id = next_window_id
+      win = Window.new(id:, buffer_id: src.buffer_id)
+      @windows[id] = win
+      ensure_initial_tabpage!
       win.cursor_x = src.cursor_x
       win.cursor_y = src.cursor_y
       win.row_offset = src.row_offset
       win.col_offset = src.col_offset
-      @window_layout = layout.to_sym
+
+      split_type = (layout.to_sym == :vertical ? :vsplit : :hsplit)
+      new_leaf = { type: :window, id: win.id }
+
+      @layout_tree = tree_split_leaf(@layout_tree, src.id, split_type, new_leaf, place.to_sym)
+
       @current_window_id = win.id
       save_current_tabpage_state! unless @suspend_tab_autosave
       win
@@ -477,18 +649,21 @@ module RuVim
     end
 
     def close_window(id)
-      return nil if @window_order.empty?
-      return nil if @window_order.length <= 1
-      return nil unless @window_order.include?(id)
+      leaves = tree_leaves(@layout_tree)
+      return nil if leaves.empty?
+      return nil if leaves.length <= 1
+      return nil unless leaves.include?(id)
 
       save_current_tabpage_state! unless @suspend_tab_autosave
-      idx = @window_order.index(id) || 0
+      idx = leaves.index(id) || 0
       @windows.delete(id)
-      @window_order.delete(id)
       @location_lists.delete(id)
-      @current_window_id = @window_order[[idx, @window_order.length - 1].min] if @current_window_id == id
-      @current_window_id ||= @window_order.first
-      @window_layout = :single if @window_order.length <= 1
+
+      @layout_tree = tree_remove(@layout_tree, id)
+
+      new_leaves = tree_leaves(@layout_tree)
+      @current_window_id = new_leaves[[idx, new_leaves.length - 1].min] if @current_window_id == id
+      @current_window_id ||= new_leaves.first
       save_current_tabpage_state! unless @suspend_tab_autosave
       current_window
     end
@@ -499,7 +674,8 @@ module RuVim
 
       save_current_tabpage_state!
       removed = @tabpages.delete_at(@current_tabpage_index)
-      Array(removed && removed[:window_order]).each do |wid|
+      removed_tree = removed && removed[:layout_tree]
+      tree_leaves(removed_tree).each do |wid|
         @windows.delete(wid)
         @location_lists.delete(wid)
       end
@@ -517,42 +693,55 @@ module RuVim
     end
 
     def focus_next_window
-      return current_window if @window_order.length <= 1
+      order = window_order
+      return current_window if order.length <= 1
 
-      idx = @window_order.index(@current_window_id) || 0
-      focus_window(@window_order[(idx + 1) % @window_order.length])
+      idx = order.index(@current_window_id) || 0
+      focus_window(order[(idx + 1) % order.length])
     end
 
     def focus_prev_window
-      return current_window if @window_order.length <= 1
+      order = window_order
+      return current_window if order.length <= 1
 
-      idx = @window_order.index(@current_window_id) || 0
-      focus_window(@window_order[(idx - 1) % @window_order.length])
+      idx = order.index(@current_window_id) || 0
+      focus_window(order[(idx - 1) % order.length])
     end
 
     def focus_window_direction(dir)
-      return current_window if @window_order.length <= 1
-
-      case @window_layout
-      when :vertical
-        if dir == :left
-          focus_prev_window
-        elsif dir == :right
-          focus_next_window
-        else
-          current_window
-        end
-      when :horizontal
-        if dir == :up
-          focus_prev_window
-        elsif dir == :down
-          focus_next_window
-        else
-          current_window
+      leaves = tree_leaves(@layout_tree)
+      return current_window if leaves.length <= 1
+
+      rects = tree_compute_rects(@layout_tree, top: 0.0, left: 0.0, height: 1.0, width: 1.0)
+      cur = rects[@current_window_id]
+      return current_window unless cur
+
+      best_id = nil
+      best_dist = Float::INFINITY
+      cur_cx = cur[:left] + cur[:width] / 2.0
+      cur_cy = cur[:top] + cur[:height] / 2.0
+
+      rects.each do |wid, r|
+        next if wid == @current_window_id
+        rcx = r[:left] + r[:width] / 2.0
+        rcy = r[:top] + r[:height] / 2.0
+
+        in_direction = case dir
+                       when :left  then rcx < cur_cx
+                       when :right then rcx > cur_cx
+                       when :up    then rcy < cur_cy
+                       when :down  then rcy > cur_cy
+                       end
+        next unless in_direction
+
+        dist = (rcx - cur_cx).abs + (rcy - cur_cy).abs
+        if dist < best_dist
+          best_dist = dist
+          best_id = wid
         end
-      else
-        focus_next_window
       end
+
+      best_id ? focus_window(best_id) : current_window
     end
 
     def switch_to_buffer(buffer_id)
@@ -570,9 +759,16 @@ module RuVim
     end
 
     def open_path(path)
+      handler = @open_path_handler
+      return handler.call(path) if handler
+
+      open_path_sync(path)
+    end
+
+    def open_path_sync(path)
       buffer = add_buffer_from_file(path)
       switch_to_buffer(buffer.id)
-      echo(path && File.exist?(path) ? "\"#{path}\" #{buffer.line_count}L" : "\"#{path}\" [New File]")
+      echo("[New File]") unless path && File.exist?(path)
       buffer
     end
 
@@ -608,7 +804,7 @@ module RuVim
       current_buffer.replace_all_lines!(intro_lines)
       current_buffer.configure_special!(kind: :intro, name: "[Intro]", readonly: true, modifiable: false)
       current_buffer.modified = false
-      current_buffer.options["filetype"] = "help"
+      assign_filetype(current_buffer, "help")
       current_window.cursor_x = 0
       current_window.cursor_y = 0
       current_window.row_offset = 0
@@ -621,7 +817,7 @@ module RuVim
       return false unless current_buffer.intro_buffer?
 
       current_buffer.become_normal_empty_buffer!
-      current_buffer.options["filetype"] = nil
+      assign_filetype(current_buffer, nil)
       current_window.cursor_x = 0
       current_window.cursor_y = 0
       current_window.row_offset = 0
@@ -641,8 +837,56 @@ module RuVim
       ids[(idx + step) % ids.length]
     end
 
+    def delete_buffer(buffer_id)
+      id = buffer_id.to_i
+      buffer = @buffers[id]
+      return nil unless buffer
+
+      if @buffers.length <= 1
+        replacement = add_empty_buffer
+      else
+        replacement = nil
+      end
+
+      fallback_id =
+        if replacement
+          replacement.id
+        else
+          candidates = @buffers.keys.reject { |bid| bid == id }
+          alt = @alternate_buffer_id
+          (alt && alt != id && @buffers.key?(alt)) ? alt : candidates.first
+        end
+
+      @windows.each_value do |win|
+        next unless win.buffer_id == id
+        next unless fallback_id
+
+        win.buffer_id = fallback_id
+        win.cursor_x = 0
+        win.cursor_y = 0
+        win.row_offset = 0
+        win.col_offset = 0
+      end
+
+      @buffers.delete(id)
+      @local_marks.delete(id)
+      @alternate_buffer_id = nil if @alternate_buffer_id == id
+      save_current_tabpage_state! unless @suspend_tab_autosave
+      ensure_bootstrap_buffer! if @buffers.empty?
+      true
+    end
+
     def window_order
-      @window_order
+      tree_leaves(@layout_tree)
+    end
+
+    def window_layout
+      return :single if @layout_tree.nil? || @layout_tree[:type] == :window
+      case @layout_tree[:type]
+      when :vsplit then :vertical
+      when :hsplit then :horizontal
+      else :single
+      end
     end
 
     def tabpages
@@ -661,8 +905,12 @@ module RuVim
       @tabpages.length
     end
 
+    def tabpage_windows(tab)
+      tree_leaves(tab[:layout_tree])
+    end
+
     def window_count
-      @window_order.length
+      tree_leaves(@layout_tree).length
     end
 
     def quickfix_items
@@ -675,7 +923,7 @@ module RuVim
 
     def set_quickfix_list(items)
       ary = Array(items).map { |it| normalize_location(it)&.merge(text: (it[:text] || it["text"]).to_s) }.compact
-      @quickfix_list = { items: ary, index: ary.empty? ? nil : 0 }
+      @quickfix_list = { items: ary, index: nil }
       @quickfix_list
     end
 
@@ -688,7 +936,21 @@ module RuVim
       items = @quickfix_list[:items]
       return nil if items.empty?
 
-      @quickfix_list[:index] = ((@quickfix_list[:index] || 0) + step.to_i) % items.length
+      cur = @quickfix_list[:index]
+      @quickfix_list[:index] = if cur.nil?
+                                  step.to_i > 0 ? 0 : items.length - 1
+                                else
+                                  (cur + step.to_i) % items.length
+                                end
+      current_quickfix_item
+    end
+
+    def select_quickfix(index)
+      items = @quickfix_list[:items]
+      return nil if items.empty?
+
+      i = [[index.to_i, 0].max, items.length - 1].min
+      @quickfix_list[:index] = i
       current_quickfix_item
     end
 
@@ -702,7 +964,7 @@ module RuVim
 
     def set_location_list(items, window_id: current_window_id)
       ary = Array(items).map { |it| normalize_location(it)&.merge(text: (it[:text] || it["text"]).to_s) }.compact
-      @location_lists[window_id] = { items: ary, index: ary.empty? ? nil : 0 }
+      @location_lists[window_id] = { items: ary, index: nil }
       @location_lists[window_id]
     end
 
@@ -717,13 +979,41 @@ module RuVim
       items = list[:items]
       return nil if items.empty?
 
-      list[:index] = ((list[:index] || 0) + step.to_i) % items.length
+      cur = list[:index]
+      list[:index] = if cur.nil?
+                       step.to_i > 0 ? 0 : items.length - 1
+                     else
+                       (cur + step.to_i) % items.length
+                     end
+      current_location_list_item(window_id)
+    end
+
+    def select_location_list(index, window_id: current_window_id)
+      list = location_list(window_id)
+      items = list[:items]
+      return nil if items.empty?
+
+      i = [[index.to_i, 0].max, items.length - 1].min
+      list[:index] = i
       current_location_list_item(window_id)
     end
 
+    # Check if the path from root to the current window passes through
+    # a split node matching the direction's axis. Used by focus_or_split
+    # to decide whether to split or stay put at edges.
+    #   left/right → check for :vsplit ancestor
+    #   up/down    → check for :hsplit ancestor
+    def has_split_ancestor_on_axis?(dir)
+      target_type = case dir
+                    when :left, :right then :vsplit
+                    when :up, :down then :hsplit
+                    end
+      tree_path_has_split_type?(@layout_tree, @current_window_id, target_type)
+    end
+
     def find_window_ids_by_buffer_kind(kind)
       sym = kind.to_sym
-      @window_order.select do |wid|
+      window_order.select do |wid|
         win = @windows[wid]
         buf = win && @buffers[win.buffer_id]
         buf && buf.kind == sym
@@ -735,9 +1025,8 @@ module RuVim
       save_current_tabpage_state!
 
       with_tab_autosave_suspended do
-        @window_order = []
+        @layout_tree = nil
         @current_window_id = nil
-        @window_layout = :single
 
         buffer = path ? add_buffer_from_file(path) : add_empty_buffer
         add_window(buffer_id: buffer.id)
@@ -764,6 +1053,7 @@ module RuVim
       @mode = :normal
       @pending_count = nil
       clear_visual
+      @rich_state = nil
     end
 
     def enter_insert_mode
@@ -779,30 +1069,77 @@ module RuVim
 
     def cancel_command_line
       @command_line.clear
-      enter_normal_mode
+      leave_command_line
+    end
+
+    def leave_command_line
+      if @rich_state
+        @mode = :rich
+        @pending_count = nil
+      else
+        enter_normal_mode
+      end
     end
 
     def echo(msg)
       @message_kind = :info
       @message = msg.to_s
+      @message_deadline = nil
+    end
+
+    def echo_temporary(msg, duration_seconds:)
+      @message_kind = :info
+      @message = msg.to_s
+      dur = duration_seconds.to_f
+      @message_deadline = dur.positive? ? (Process.clock_gettime(Process::CLOCK_MONOTONIC) + dur) : nil
+    rescue StandardError
+      @message_deadline = nil
     end
 
     def echo_error(msg)
       @message_kind = :error
       @message = msg.to_s
+      @message_deadline = nil
     end
 
     def clear_message
       @message_kind = :info
       @message = ""
+      @message_deadline = nil
     end
 
     def message_error?
       !@message.to_s.empty? && @message_kind == :error
     end
 
+    def transient_message_timeout_seconds(now: nil)
+      return nil unless @message_deadline
+      return nil if message_error?
+      return nil if command_line_active?
+
+      now ||= Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      [@message_deadline - now, 0.0].max
+    rescue StandardError
+      nil
+    end
+
+    def clear_expired_transient_message!(now: nil)
+      return false unless @message_deadline
+      return false if message_error?
+      return false if command_line_active?
+
+      now ||= Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      return false if now < @message_deadline
+
+      clear_message
+      true
+    rescue StandardError
+      false
+    end
+
     def text_viewport_size(rows:, cols:)
-      text_rows = command_area_active? ? rows - 2 : rows - 1
+      # Reserve one status row + one command/error row at the bottom.
+      text_rows = rows - 2
       [text_rows, cols]
     end
 
@@ -814,8 +1151,69 @@ module RuVim
       command_line_active? || message_error?
     end
 
+    def assign_filetype(buffer, ft)
+      buffer.options["filetype"] = ft
+      buffer.lang_module = resolve_lang_module(ft)
+    end
+
     private
 
+    def resolve_lang_module(ft)
+      case ft
+      when "ruby" then Lang::Ruby
+      else Lang::Base
+      end
+    end
+
+    def detect_filetype_from_shebang(path)
+      line = read_first_line(path)
+      return nil unless line.start_with?("#!")
+
+      cmd = shebang_command_name(line)
+      return nil if cmd.nil? || cmd.empty?
+
+      rule = SHEBANG_FILETYPE_RULES.find do |matcher, _filetype|
+        matcher.is_a?(Regexp) ? matcher.match?(cmd) : matcher.to_s == cmd
+      end
+      rule && rule[1]
+    rescue StandardError
+      nil
+    end
+
+    def read_first_line(path)
+      return "" unless path && !path.empty?
+      return "" unless File.file?(path)
+
+      File.open(path, "rb") do |f|
+        (f.gets || "").to_s.encode(Encoding::UTF_8, invalid: :replace, undef: :replace)
+      end
+    rescue StandardError
+      ""
+    end
+
+    def shebang_command_name(line)
+      src = line.to_s.sub(/\A#!/, "").strip
+      return nil if src.empty?
+
+      tokens = src.split(/\s+/)
+      return nil if tokens.empty?
+
+      prog = tokens[0].to_s
+      if File.basename(prog) == "env"
+        i = 1
+        while i < tokens.length && tokens[i].start_with?("-")
+          if tokens[i] == "-S"
+            i += 1
+            break
+          end
+          i += 1
+        end
+        prog = tokens[i].to_s
+      end
+
+      File.basename(prog.to_s)
+    end
+
     def default_global_options
       OPTION_DEFS.each_with_object({}) { |(k, v), h| h[k] = v[:default] }
     end
@@ -873,7 +1271,7 @@ module RuVim
 
     def assign_detected_filetype(buffer)
       ft = detect_filetype(buffer.path)
-      buffer.options["filetype"] = ft if ft && !ft.empty?
+      assign_filetype(buffer, ft) if ft && !ft.empty?
       buffer
     end
 
@@ -910,6 +1308,51 @@ module RuVim
       current_location
     end
 
+    def arglist
+      @arglist.dup
+    end
+
+    def arglist_index
+      @arglist_index
+    end
+
+    def set_arglist(paths)
+      @arglist = Array(paths).dup
+      @arglist_index = 0
+    end
+
+    def arglist_current
+      @arglist[@arglist_index] if @arglist_index < @arglist.length
+    end
+
+    def arglist_next(count = 1)
+      new_index = @arglist_index + count
+      if new_index >= @arglist.length
+        raise RuVim::CommandError, "Already at last argument"
+      end
+      @arglist_index = new_index
+      @arglist[@arglist_index]
+    end
+
+    def arglist_prev(count = 1)
+      new_index = @arglist_index - count
+      if new_index < 0
+        raise RuVim::CommandError, "Already at first argument"
+      end
+      @arglist_index = new_index
+      @arglist[@arglist_index]
+    end
+
+    def arglist_first
+      @arglist_index = 0
+      @arglist[@arglist_index] if @arglist.length > 0
+    end
+
+    def arglist_last
+      @arglist_index = [@arglist.length - 1, 0].max
+      @arglist[@arglist_index] if @arglist.length > 0
+    end
+
     private
 
     def first_nonblank_col(buffer, row)
@@ -950,6 +1393,15 @@ module RuVim
       key == "+" || key == "*"
     end
 
+    def clipboard_default_register_key
+      spec = @global_options["clipboard"].to_s
+      parts = spec.split(",").map { |s| s.strip.downcase }.reject(&:empty?)
+      return "+" if parts.include?("unnamedplus")
+      return "*" if parts.include?("unnamed")
+
+      nil
+    end
+
     def write_clipboard_register(key, payload)
       return unless clipboard_register?(key.downcase)
 
@@ -967,7 +1419,7 @@ module RuVim
 
     def ensure_initial_tabpage!
       return unless @tabpages.empty?
-      return if @window_order.empty?
+      return if @layout_tree.nil?
 
       @tabpages << new_tabpage_snapshot
       @current_tabpage_index = 0
@@ -981,18 +1433,16 @@ module RuVim
     end
 
     def load_tabpage_state!(tab)
-      @window_order = tab[:window_order].dup
+      @layout_tree = tree_deep_dup(tab[:layout_tree])
       @current_window_id = tab[:current_window_id]
-      @window_layout = tab[:window_layout]
       current_window
     end
 
     def new_tabpage_snapshot(id: nil)
       {
         id: id || next_tabpage_id,
-        window_order: @window_order.dup,
-        current_window_id: @current_window_id,
-        window_layout: @window_layout
+        layout_tree: tree_deep_dup(@layout_tree),
+        current_window_id: @current_window_id
       }
     end
 
@@ -1021,5 +1471,108 @@ module RuVim
     ensure
       @suspend_tab_autosave = prev
     end
+
+    # --- Layout tree helpers ---
+
+    def tree_leaves(node)
+      return [] if node.nil?
+      return [node[:id]] if node[:type] == :window
+
+      node[:children].flat_map { |c| tree_leaves(c) }
+    end
+
+    def tree_deep_dup(node)
+      return nil if node.nil?
+      return { type: :window, id: node[:id] } if node[:type] == :window
+
+      { type: node[:type], children: node[:children].map { |c| tree_deep_dup(c) } }
+    end
+
+    # Split a leaf node into a new split node. If the parent is already the same
+    # split type, merge into the parent instead of nesting.
+    def tree_split_leaf(node, target_id, split_type, new_leaf, place)
+      if node[:type] == :window
+        if node[:id] == target_id
+          children = place == :before ? [new_leaf, node] : [node, new_leaf]
+          return { type: split_type, children: children }
+        end
+        return node
+      end
+
+      new_children = node[:children].flat_map do |child|
+        result = tree_split_leaf(child, target_id, split_type, new_leaf, place)
+        # If the child was replaced with the same split type as this node, merge
+        if result[:type] == node[:type] && result != child
+          result[:children]
+        else
+          [result]
+        end
+      end
+
+      { type: node[:type], children: new_children }
+    end
+
+    def tree_remove(node, target_id)
+      return nil if node.nil?
+      return nil if node[:type] == :window && node[:id] == target_id
+      return node if node[:type] == :window
+
+      new_children = node[:children].filter_map { |c| tree_remove(c, target_id) }
+      return nil if new_children.empty?
+      return new_children.first if new_children.length == 1
+
+      { type: node[:type], children: new_children }
+    end
+
+    # Check if the path from root to the target window passes through
+    # a split node of the given type. Returns true if any ancestor of the
+    # target window in the tree has type == split_type.
+    def tree_path_has_split_type?(node, target_id, split_type)
+      return false if node.nil?
+      return false if node[:type] == :window
+      # Check if target is in any child subtree
+      node[:children].each do |child|
+        if tree_subtree_contains?(child, target_id)
+          return true if node[:type] == split_type
+          return tree_path_has_split_type?(child, target_id, split_type)
+        end
+      end
+      false
+    end
+
+    def tree_subtree_contains?(node, target_id)
+      return false if node.nil?
+      return node[:id] == target_id if node[:type] == :window
+      node[:children].any? { |c| tree_subtree_contains?(c, target_id) }
+    end
+
+    # Compute normalized rects (0.0–1.0 coordinate space) for direction finding.
+    # Separators are ignored here — this is purely for adjacency/direction logic.
+    def tree_compute_rects(node, top:, left:, height:, width:)
+      return {} if node.nil?
+
+      if node[:type] == :window
+        return { node[:id] => { top: top, left: left, height: height, width: width } }
+      end
+
+      children = node[:children]
+      n = children.length
+      rects = {}
+
+      case node[:type]
+      when :vsplit
+        w_each = width / n.to_f
+        children.each_with_index do |child, i|
+          rects.merge!(tree_compute_rects(child, top: top, left: left + i * w_each, height: height, width: w_each))
+        end
+      when :hsplit
+        h_each = height / n.to_f
+        children.each_with_index do |child, i|
+          rects.merge!(tree_compute_rects(child, top: top + i * h_each, left: left, height: h_each, width: width))
+        end
+      end
+
+      rects
+    end
   end
 end