ruvim 0.4.0 → 0.6.0

data/lib/ruvim/dispatcher.rb

@@ -21,9 +21,9 @@ module RuVim
     end
 
     def dispatch_ex(editor, line)
-      raw = line.to_s.strip
+      raw = line.strip
       if raw.start_with?("!")
-        command = raw[1..].to_s.strip
+        command = raw[1..].strip
         invocation = CommandInvocation.new(id: "__shell__", argv: [command])
         ctx = Context.new(editor:, invocation:)
         @command_host.ex_shell(ctx, command:)
@@ -52,15 +52,21 @@ module RuVim
       return if parsed.nil?
 
       spec = @ex_registry.fetch(parsed.name)
-      validate_ex_args!(spec, parsed.argv, parsed.bang)
-      invocation = CommandInvocation.new(id: spec.name, argv: parsed.argv, bang: parsed.bang)
+      argv = parsed.argv
+      if spec.raw_args
+        # Re-extract raw text after command name (preserving shell quoting)
+        raw_rest = rest.strip.sub(/\A\S+\s*/, "")
+        argv = raw_rest.empty? ? [] : [raw_rest]
+      end
+      validate_ex_args!(spec, argv, parsed.bang)
+      invocation = CommandInvocation.new(id: spec.name, argv: argv, bang: parsed.bang)
       ctx = Context.new(editor:, invocation:)
       range_kwargs = {}
       if range_result
         range_kwargs[:range_start] = range_result[:range_start]
         range_kwargs[:range_end] = range_result[:range_end]
       end
-      @command_host.call(spec.call, ctx, argv: parsed.argv, bang: parsed.bang, count: 1, kwargs: range_kwargs)
+      @command_host.call(spec.call, ctx, argv: argv, bang: parsed.bang, count: 1, kwargs: range_kwargs)
     rescue StandardError => e
       editor.echo_error("Error: #{e.message}")
     ensure
@@ -68,7 +74,7 @@ module RuVim
     end
 
     def parse_ex(line)
-      raw = line.to_s.strip
+      raw = line.strip
       return nil if raw.empty?
 
       tokens = Shellwords.shellsplit(raw)
@@ -85,7 +91,7 @@ module RuVim
     # Parse a substitute command: s/pat/repl/flags
     # Returns {pattern:, replacement:, flags_str:} or nil
     def parse_substitute(line)
-      raw = line.to_s.strip
+      raw = line.strip
       return nil unless raw.match?(/\As[^a-zA-Z]/)
       return nil if raw.length < 2
 
@@ -189,7 +195,7 @@ module RuVim
     # Parse a range from the beginning of raw.
     # Returns {range_start:, range_end:, rest:} or nil.
     def parse_range(raw, editor)
-      str = raw.to_s
+      str = raw
       return nil if str.empty?
 
       # % = whole file

data/lib/ruvim/display_width.rb

@@ -1,24 +1,103 @@
 # frozen_string_literal: true
 
+# Try loading the C extension (built by rake compile)
+begin
+  require_relative "ruvim_ext"
+rescue LoadError
+  # C extension not available — pure Ruby fallback below
+end
+
 module RuVim
   module DisplayWidth
     module_function
 
-    def cell_width(ch, col: 0, tabstop: 2)
-      return 1 if ch.nil? || ch.empty?
+    if defined?(RuVim::DisplayWidthExt)
+      # ---- C extension paths ----
+
+      def cell_width(ch, col: 0, tabstop: 2)
+        sync_ambiguous_width
+        DisplayWidthExt.cell_width(ch, col:, tabstop:)
+      end
+
+      def display_width(str, tabstop: 2, start_col: 0)
+        sync_ambiguous_width
+        DisplayWidthExt.display_width(str, tabstop:, start_col:)
+      end
+
+      def expand_tabs(str, tabstop: 2, start_col: 0)
+        sync_ambiguous_width
+        DisplayWidthExt.expand_tabs(str, tabstop:, start_col:)
+      end
+
+      def ambiguous_width
+        sync_ambiguous_width
+      end
+
+      def sync_ambiguous_width
+        env = ::ENV["RUVIM_AMBIGUOUS_WIDTH"]
+        if !defined?(@ambiguous_width_cached) || @ambiguous_width_env != env
+          @ambiguous_width_env = env
+          @ambiguous_width_cached = (env == "2" ? 2 : 1)
+          DisplayWidthExt.set_ambiguous_width(@ambiguous_width_cached)
+        end
+        @ambiguous_width_cached
+      end
+    else
+      # ---- Pure Ruby fallback ----
+
+      def cell_width(ch, col: 0, tabstop: 2)
+        return 1 if ch.nil? || ch.empty?
+
+        if ch == "\t"
+          width = tabstop - (col % tabstop)
+          return width.zero? ? tabstop : width
+        end
+
+        # Fast path: byte length 1 means ASCII — always width 1
+        return 1 if ch.bytesize == 1
+
+        code = ch.ord
+        return cached_codepoint_width(code) if codepoint_cacheable?(code)
 
-      if ch == "\t"
-        width = tabstop - (col % tabstop)
-        return width.zero? ? tabstop : width
+        uncached_codepoint_width(code)
       end
 
-      code = ch.ord
-      return 1 if code <= 0xA0 && !code.zero?
-      return cached_codepoint_width(code) if codepoint_cacheable?(code)
+      def display_width(str, tabstop: 2, start_col: 0)
+        col = start_col
+        str.to_s.each_char { |ch| col += cell_width(ch, col:, tabstop:) }
+        col - start_col
+      end
+
+      def expand_tabs(str, tabstop: 2, start_col: 0)
+        col = start_col
+        out = +""
+        str.to_s.each_char do |ch|
+          if ch == "\t"
+            n = cell_width(ch, col:, tabstop:)
+            out << (" " * n)
+            col += n
+          else
+            out << ch
+            col += cell_width(ch, col:, tabstop:)
+          end
+        end
+        out
+      end
+
+      def ambiguous_width
+        env = ::ENV["RUVIM_AMBIGUOUS_WIDTH"]
+        if !defined?(@ambiguous_width_cached) || @ambiguous_width_env != env
+          @ambiguous_width_env = env
+          @ambiguous_width_cached = (env == "2" ? 2 : 1)
+          @codepoint_width_cache = {}
+        end
 
-      uncached_codepoint_width(code)
+        @ambiguous_width_cached
+      end
     end
 
+    # Shared helpers (used by pure Ruby path; kept available for tests)
+
     def codepoint_cacheable?(code)
       !code.nil? && !code.zero?
     end
@@ -43,28 +122,6 @@ module RuVim
       1
     end
 
-    def display_width(str, tabstop: 2, start_col: 0)
-      col = start_col
-      str.to_s.each_char { |ch| col += cell_width(ch, col:, tabstop:) }
-      col - start_col
-    end
-
-    def expand_tabs(str, tabstop: 2, start_col: 0)
-      col = start_col
-      out = +""
-      str.to_s.each_char do |ch|
-        if ch == "\t"
-          n = cell_width(ch, col:, tabstop:)
-          out << (" " * n)
-          col += n
-        else
-          out << ch
-          col += cell_width(ch, col:, tabstop:)
-        end
-      end
-      out
-    end
-
     def combining_mark?(code)
       (0x0300..0x036F).cover?(code) ||
         (0x1AB0..0x1AFF).cover?(code) ||
@@ -74,9 +131,9 @@ module RuVim
     end
 
     def zero_width_codepoint?(code)
-      (0x200D..0x200D).cover?(code) || # ZWJ
-        (0xFE00..0xFE0F).cover?(code) || # variation selectors
-        (0xE0100..0xE01EF).cover?(code)  # variation selectors supplement
+      (0x200D..0x200D).cover?(code) ||
+        (0xFE00..0xFE0F).cover?(code) ||
+        (0xE0100..0xE01EF).cover?(code)
     end
 
     def wide_codepoint?(code)
@@ -121,16 +178,5 @@ module RuVim
         (0x2460..0x24E9).cover?(code) ||
         (0x2500..0x257F).cover?(code)
     end
-
-    def ambiguous_width
-      env = ::ENV["RUVIM_AMBIGUOUS_WIDTH"]
-      if !defined?(@ambiguous_width_cached) || @ambiguous_width_env != env
-        @ambiguous_width_env = env
-        @ambiguous_width_cached = (env == "2" ? 2 : 1)
-        @codepoint_width_cache = {}
-      end
-
-      @ambiguous_width_cached
-    end
   end
 end

data/lib/ruvim/editor.rb

@@ -54,24 +54,12 @@ module RuVim
       "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" }
+      "grepformat" => { default_scope: :global, type: :string, default: "%f:%l:%m" },
+      "runprg" => { default_scope: :buffer, type: :string, default: nil }
     }.freeze
-    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, :git_stream_handler, :git_stream_stop_handler
+    attr_accessor :current_window_id, :mode, :message, :pending_count, :alternate_buffer_id, :restricted_mode, :current_window_view_height_hint, :open_path_handler, :keymap_manager, :app_action_handler, :git_stream_handler, :git_stream_stop_handler, :shell_executor, :run_stream_handler
 
     def initialize
       @buffers = {}
@@ -93,7 +81,6 @@ module RuVim
       @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
@@ -117,6 +104,8 @@ module RuVim
       @arglist = []
       @arglist_index = 0
       @hit_enter_lines = nil
+      @run_history = {}  # buffer_id => last run command (unexpanded)
+      @run_output_buffer_id = nil
     end
 
     def running?
@@ -131,6 +120,18 @@ module RuVim
       @running = false
     end
 
+    def run_history
+      @run_history
+    end
+
+    def run_output_buffer_id
+      @run_output_buffer_id
+    end
+
+    def run_output_buffer_id=(id)
+      @run_output_buffer_id = id
+    end
+
     def command_line
       @command_line
     end
@@ -152,7 +153,7 @@ module RuVim
     end
 
     def set_last_search(pattern:, direction:)
-      @last_search = { pattern: pattern.to_s, direction: direction.to_sym }
+      @last_search = { pattern: pattern, direction: direction }
       @hlsearch_suppressed = false
     end
 
@@ -165,7 +166,7 @@ module RuVim
     end
 
     def set_last_find(char:, direction:, till:)
-      @last_find = { char: char.to_s, direction: direction.to_sym, till: !!till }
+      @last_find = { char: char, direction: direction, till: !!till }
     end
 
     def current_window
@@ -176,19 +177,18 @@ module RuVim
       @buffers.fetch(current_window.buffer_id)
     end
 
-    def stdin_stream_stop_or_cancel!
-      handler = @stdin_stream_stop_handler
+    def stream_stop_or_cancel!
+      handler = current_buffer&.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)
+      handler.call(name, **kwargs)
       true
     end
 
@@ -213,7 +213,7 @@ module RuVim
 
     def get_option(name, scope: :effective, window: current_window, buffer: current_buffer)
       key = name.to_s
-      case scope.to_sym
+      case scope
       when :global
         @global_options[key]
       when :buffer
@@ -228,7 +228,7 @@ module RuVim
     def set_option(name, value, scope: :auto, window: current_window, buffer: current_buffer)
       key = name.to_s
       value = coerce_option_value(key, value)
-      actual_scope = (scope.to_sym == :auto ? option_default_scope(key) : scope.to_sym)
+      actual_scope = (scope == :auto ? option_default_scope(key) : scope)
       case actual_scope
       when :global
         @global_options[key] = value
@@ -262,34 +262,13 @@ module RuVim
       return nil if p.empty?
 
       base = File.basename(p)
-      return "ruby" if %w[Gemfile Rakefile Guardfile].include?(base)
-
-      ext_ft = {
-        ".rb" => "ruby",
-        ".rake" => "ruby",
-        ".ru" => "ruby",
-        ".py" => "python",
-        ".js" => "javascript",
-        ".mjs" => "javascript",
-        ".cjs" => "javascript",
-        ".ts" => "typescript",
-        ".tsx" => "typescriptreact",
-        ".jsx" => "javascriptreact",
-        ".json" => "json",
-        ".jsonl" => "jsonl",
-        ".yml" => "yaml",
-        ".yaml" => "yaml",
-        ".md" => "markdown",
-        ".txt" => "text",
-        ".html" => "html",
-        ".css" => "css",
-        ".sh" => "sh",
-        ".tsv" => "tsv",
-        ".csv" => "csv",
-        ".scm" => "scheme",
-        ".ss" => "scheme",
-        ".sld" => "scheme"
-      }[File.extname(base).downcase]
+
+      # Basename-based detection (exact match, then prefix)
+      base_ft = Lang::Registry.detect_by_basename(base)
+      return base_ft if base_ft
+
+      # Extension-based detection
+      ext_ft = Lang::Registry.detect_by_extension(File.extname(base))
       return ext_ft if ext_ft
 
       detect_filetype_from_shebang(p)
@@ -301,9 +280,9 @@ module RuVim
 
     def set_register(name = "\"", text:, type: :charwise)
       key = name.to_s
-      return { text: text.to_s, type: type.to_sym } if key == "_"
+      return { text: text, type: type } if key == "_"
 
-      payload = write_register_payload(key, text: text.to_s, type: type.to_sym)
+      payload = write_register_payload(key, text: text, type: type)
       write_clipboard_register(key, payload)
       if key == "\""
         if (default_clip = clipboard_default_register_key)
@@ -316,14 +295,14 @@ module RuVim
     end
 
     def store_operator_register(name = "\"", text:, type:, kind:)
-      key = (name || "\"").to_s
-      payload = { text: text.to_s, type: type.to_sym }
+      key = (name || "\"")
+      payload = { text: text, type: type }
       return payload if key == "_"
 
       written = set_register(key, text: payload[:text], type: payload[:type])
       op_payload = dup_register_payload(written)
 
-      case kind.to_sym
+      case kind
       when :yank
         @registers["0"] = dup_register_payload(op_payload)
       when :delete, :change
@@ -485,9 +464,9 @@ module RuVim
     end
 
     def enter_visual(mode)
-      @mode = mode.to_sym
+      @mode = mode
       @visual_state = {
-        mode: mode.to_sym,
+        mode: mode,
         anchor_y: current_window.cursor_y,
         anchor_x: current_window.cursor_x
       }
@@ -645,10 +624,10 @@ module RuVim
       win.row_offset = src.row_offset
       win.col_offset = src.col_offset
 
-      split_type = (layout.to_sym == :vertical ? :vsplit : :hsplit)
+      split_type = (layout == :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)
+      @layout_tree = tree_split_leaf(@layout_tree, src.id, split_type, new_leaf, place)
 
       @current_window_id = win.id
       save_current_tabpage_state! unless @suspend_tab_autosave
@@ -849,8 +828,7 @@ module RuVim
     end
 
     def delete_buffer(buffer_id)
-      id = buffer_id.to_i
-      buffer = @buffers[id]
+      buffer = @buffers[buffer_id]
       return nil unless buffer
 
       if @buffers.length <= 1
@@ -863,13 +841,13 @@ module RuVim
         if replacement
           replacement.id
         else
-          candidates = @buffers.keys.reject { |bid| bid == id }
+          candidates = @buffers.keys.reject { |bid| bid == buffer_id }
           alt = @alternate_buffer_id
-          (alt && alt != id && @buffers.key?(alt)) ? alt : candidates.first
+          (alt && alt != buffer_id && @buffers.key?(alt)) ? alt : candidates.first
         end
 
       @windows.each_value do |win|
-        next unless win.buffer_id == id
+        next unless win.buffer_id == buffer_id
         next unless fallback_id
 
         win.buffer_id = fallback_id
@@ -879,9 +857,9 @@ module RuVim
         win.col_offset = 0
       end
 
-      @buffers.delete(id)
-      @local_marks.delete(id)
-      @alternate_buffer_id = nil if @alternate_buffer_id == id
+      @buffers.delete(buffer_id)
+      @local_marks.delete(buffer_id)
+      @alternate_buffer_id = nil if @alternate_buffer_id == buffer_id
       save_current_tabpage_state! unless @suspend_tab_autosave
       ensure_bootstrap_buffer! if @buffers.empty?
       true
@@ -1023,11 +1001,10 @@ module RuVim
     end
 
     def find_window_ids_by_buffer_kind(kind)
-      sym = kind.to_sym
       window_order.select do |wid|
         win = @windows[wid]
         buf = win && @buffers[win.buffer_id]
-        buf && buf.kind == sym
+        buf && buf.kind == kind
       end
     end
 
@@ -1165,15 +1142,24 @@ module RuVim
     def assign_filetype(buffer, ft)
       buffer.options["filetype"] = ft
       buffer.lang_module = resolve_lang_module(ft)
+      apply_filetype_defaults(buffer, ft)
+    end
+
+    def apply_filetype_defaults(buffer, ft)
+      unless buffer.options.key?("runprg")
+        runprg = filetype_default_runprg(ft)
+        buffer.options["runprg"] = runprg if runprg
+      end
+    end
+
+    def filetype_default_runprg(ft)
+      Lang::Registry.runprg_for(ft)
     end
 
     private
 
     def resolve_lang_module(ft)
-      case ft
-      when "ruby" then Lang::Ruby
-      else Lang::Base
-      end
+      Lang::Registry.resolve_module(ft)
     end
 
     def detect_filetype_from_shebang(path)
@@ -1183,10 +1169,7 @@ module RuVim
       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]
+      Lang::Registry.detect_by_shebang(cmd)
     rescue StandardError
       nil
     end
@@ -1222,7 +1205,7 @@ module RuVim
         prog = tokens[i].to_s
       end
 
-      File.basename(prog.to_s)
+      File.basename(prog)
     end
 
     def default_global_options
@@ -1277,7 +1260,7 @@ module RuVim
     def dup_register_payload(payload)
       return nil unless payload
 
-      { text: payload[:text].to_s.dup, type: payload[:type].to_sym }
+      { text: payload[:text].dup, type: payload[:type] }
     end
 
     def assign_detected_filetype(buffer)

data/lib/ruvim/ex_command_registry.rb

@@ -9,6 +9,7 @@ module RuVim
       :desc,
       :nargs,
       :bang,
+      :raw_args,
       :source,
       keyword_init: true
     )
@@ -20,7 +21,7 @@ module RuVim
       @lookup = {}
     end
 
-    def register(name, call:, aliases: [], desc: "", nargs: :any, bang: false, source: :builtin)
+    def register(name, call:, aliases: [], desc: "", nargs: :any, bang: false, raw_args: false, source: :builtin)
       canonical = name.to_s
       if @specs.key?(canonical)
         raise RuVim::CommandError, "Ex command already exists: #{canonical}"
@@ -32,6 +33,7 @@ module RuVim
         desc: desc,
         nargs: nargs,
         bang: bang,
+        raw_args: raw_args,
         source: source
       )