ruvim 0.1.0

data/lib/ruvim/clipboard.rb

@@ -0,0 +1,73 @@
+require "open3"
+
+module RuVim
+  module Clipboard
+    module_function
+
+    def available?
+      !backend.nil?
+    end
+
+    def read
+      cmd = backend&.dig(:read)
+      return nil unless cmd
+
+      out, status = Open3.capture2(*cmd)
+      return nil unless status.success?
+
+      out
+    rescue StandardError
+      nil
+    end
+
+    def write(text)
+      cmd = backend&.dig(:write)
+      return false unless cmd
+
+      Open3.popen2(*cmd) do |stdin, _stdout, wait|
+        stdin.write(text.to_s)
+        stdin.close
+        return wait.value.success?
+      end
+    rescue StandardError
+      false
+    end
+
+    def reset_backend!
+      @backend = nil
+    end
+
+    def backend
+      @backend ||= detect_backend
+    end
+
+    def detect_backend
+      return pbcopy_backend if command_available?("pbcopy") && command_available?("pbpaste")
+      return wayland_backend if command_available?("wl-copy") && command_available?("wl-paste")
+      return xclip_backend if command_available?("xclip")
+      return xsel_backend if command_available?("xsel")
+
+      nil
+    end
+
+    def pbcopy_backend
+      { write: %w[pbcopy], read: %w[pbpaste] }
+    end
+
+    def wayland_backend
+      { write: %w[wl-copy], read: %w[wl-paste -n] }
+    end
+
+    def xclip_backend
+      { write: %w[xclip -selection clipboard -in], read: %w[xclip -selection clipboard -out] }
+    end
+
+    def xsel_backend
+      { write: %w[xsel --clipboard --input], read: %w[xsel --clipboard --output] }
+    end
+
+    def command_available?(name)
+      system("which", name, out: File::NULL, err: File::NULL)
+    end
+  end
+end

data/lib/ruvim/command_invocation.rb

@@ -0,0 +1,14 @@
+module RuVim
+  class CommandInvocation
+    attr_accessor :id, :argv, :kwargs, :count, :bang, :raw_keys
+
+    def initialize(id:, argv: nil, kwargs: nil, count: nil, bang: nil, raw_keys: nil)
+      @id = id
+      @argv = argv || []
+      @kwargs = kwargs || {}
+      @count = count || 1
+      @bang = !!bang
+      @raw_keys = raw_keys
+    end
+  end
+end

data/lib/ruvim/command_line.rb

@@ -0,0 +1,63 @@
+module RuVim
+  class CommandLine
+    attr_reader :prefix, :text, :cursor
+
+    def initialize
+      reset(prefix: ":")
+    end
+
+    def reset(prefix: ":")
+      @prefix = prefix
+      @text = +""
+      @cursor = 0
+    end
+
+    def clear
+      @text.clear
+      @cursor = 0
+    end
+
+    def replace_text(str)
+      @text = str.to_s.dup
+      @cursor = @text.length
+    end
+
+    def replace_span(start_idx, end_idx, replacement, cursor_at: :end)
+      s = [[start_idx.to_i, 0].max, @text.length].min
+      e = [[end_idx.to_i, s].max, @text.length].min
+      rep = replacement.to_s
+      @text = @text[0...s].to_s + rep + @text[e..].to_s
+      @cursor =
+        case cursor_at
+        when :start then s
+        when Integer then [[cursor_at, 0].max, @text.length].min
+        else
+          s + rep.length
+        end
+    end
+
+    def insert(str)
+      @text.insert(@cursor, str)
+      @cursor += str.length
+    end
+
+    def backspace
+      return if @cursor.zero?
+
+      @text.slice!(@cursor - 1)
+      @cursor -= 1
+    end
+
+    def move_left
+      @cursor -= 1 if @cursor.positive?
+    end
+
+    def move_right
+      @cursor += 1 if @cursor < @text.length
+    end
+
+    def content
+      "#{@prefix}#{@text}"
+    end
+  end
+end

data/lib/ruvim/command_registry.rb

@@ -0,0 +1,38 @@
+module RuVim
+  class CommandRegistry
+    CommandSpec = Struct.new(
+      :id,
+      :call,
+      :desc,
+      :source,
+      keyword_init: true
+    )
+
+    include Singleton
+
+    def initialize
+      @specs = {}
+    end
+
+    def register(id, call:, desc: "", source: :builtin)
+      key = id.to_s
+      @specs[key] = CommandSpec.new(id: key, call:, desc:, source:)
+    end
+
+    def fetch(id)
+      @specs.fetch(id.to_s)
+    end
+
+    def registered?(id)
+      @specs.key?(id.to_s)
+    end
+
+    def all
+      @specs.values.sort_by(&:id)
+    end
+
+    def clear!
+      @specs.clear
+    end
+  end
+end

data/lib/ruvim/config_dsl.rb

@@ -0,0 +1,134 @@
+module RuVim
+  class ConfigDSL < BasicObject
+    def initialize(command_registry:, ex_registry:, keymaps:, command_host:, editor: nil, filetype: nil)
+      @command_registry = command_registry
+      @ex_registry = ex_registry
+      @keymaps = keymaps
+      @command_host = command_host
+      @editor = editor
+      @filetype = filetype&.to_s
+      @inline_map_command_seq = 0
+    end
+
+    def nmap(seq, command_id = nil, desc: "user keymap", **opts, &block)
+      command_id = inline_map_command_id(:normal, seq, desc:, &block) if block
+      raise ::ArgumentError, "command_id or block required" if command_id.nil?
+
+      if @filetype && !@filetype.empty?
+        @keymaps.bind_filetype(@filetype, seq, command_id.to_s, mode: :normal, **opts)
+      else
+        @keymaps.bind(:normal, seq, command_id.to_s, **opts)
+      end
+    end
+
+    def imap(seq, command_id = nil, desc: "user keymap", **opts, &block)
+      command_id = inline_map_command_id(:insert, seq, desc:, &block) if block
+      raise ::ArgumentError, "command_id or block required" if command_id.nil?
+
+      if @filetype && !@filetype.empty?
+        @keymaps.bind_filetype(@filetype, seq, command_id.to_s, mode: :insert, **opts)
+      else
+        @keymaps.bind(:insert, seq, command_id.to_s, **opts)
+      end
+    end
+
+    def map_global(seq, command_id = nil, mode: :normal, desc: "user keymap", **opts, &block)
+      command_id = inline_map_command_id(mode || :global, seq, desc:, &block) if block
+      raise ::ArgumentError, "command_id or block required" if command_id.nil?
+
+      if mode
+        @keymaps.bind(mode.to_sym, seq, command_id.to_s, **opts)
+      else
+        @keymaps.bind_global(seq, command_id.to_s, **opts)
+      end
+    end
+
+    def command(id, desc: "user command", &block)
+      raise ::ArgumentError, "block required" unless block
+
+      @command_registry.register(id.to_s, call: block, desc:, source: :user)
+    end
+
+    def ex_command(name, desc: "user ex", aliases: [], nargs: :any, bang: false, &block)
+      raise ::ArgumentError, "block required" unless block
+
+      @ex_registry.unregister(name.to_s) if @ex_registry.registered?(name.to_s)
+      @ex_registry.register(name.to_s, call: block, desc:, aliases:, nargs:, bang:, source: :user)
+    end
+
+    # Convenience: define an Ex command that forwards to an existing internal command ID.
+    def ex_command_call(name, command_id, desc: "user ex", aliases: [], nargs: :any, bang: false)
+      ex_command(name, desc:, aliases:, nargs:, bang:) do |ctx, argv:, kwargs:, bang:, count:|
+        spec = @command_registry.fetch(command_id.to_s)
+        @command_host.call(spec.call, ctx, argv:, kwargs:, bang:, count:)
+      end
+    end
+
+    def set(option_expr)
+      apply_option_expr(option_expr, scope: :auto)
+    end
+
+    def setlocal(option_expr)
+      apply_option_expr(option_expr, scope: :local)
+    end
+
+    def setglobal(option_expr)
+      apply_option_expr(option_expr, scope: :global)
+    end
+
+    private
+
+    def inline_map_command_id(mode, seq, desc:, &block)
+      raise ::ArgumentError, "block required" unless block
+
+      @inline_map_command_seq += 1
+      id = "user.keymap.#{normalize_mode_name(mode)}.#{sanitize_seq_label(seq)}.#{@inline_map_command_seq}"
+      command(id, desc:, &block)
+      id
+    end
+
+    def normalize_mode_name(mode)
+      (mode || :global).to_s
+    end
+
+    def sanitize_seq_label(seq)
+      raw =
+        case seq
+        when ::Array
+          seq.map(&:to_s).join("_")
+        else
+          seq.to_s
+        end
+      s = raw.gsub(/[^A-Za-z0-9]+/, "_").gsub(/\A_+|_+\z/, "")
+      s.empty? ? "anonymous" : s
+    end
+
+    def apply_option_expr(expr, scope:)
+      raise ::ArgumentError, "editor context required for option DSL" unless @editor
+
+      token = expr.to_s.strip
+      raise ::ArgumentError, "empty option expression" if token.empty?
+
+      if token.start_with?("no")
+        name = token[2..]
+        @editor.set_option(name, false, scope: resolve_scope(name, scope))
+        return
+      end
+
+      if token.include?("=")
+        name, raw = token.split("=", 2)
+        @editor.set_option(name, raw, scope: resolve_scope(name, scope))
+        return
+      end
+
+      @editor.set_option(token, true, scope: resolve_scope(token, scope))
+    end
+
+    def resolve_scope(name, scope)
+      return :auto if scope == :auto
+      return :global if scope == :global
+
+      @editor.option_default_scope(name) == :buffer ? :buffer : :window
+    end
+  end
+end

data/lib/ruvim/config_loader.rb

@@ -0,0 +1,68 @@
+module RuVim
+  class ConfigLoader
+    def initialize(command_registry:, ex_registry:, keymaps:, command_host:)
+      @command_registry = command_registry
+      @ex_registry = ex_registry
+      @keymaps = keymaps
+      @command_host = command_host
+    end
+
+    def load_default!
+      path = xdg_config_path
+      return nil unless File.file?(path)
+
+      load_file(path)
+    end
+
+    def load_file(path, editor: nil, filetype: nil)
+      dsl = ConfigDSL.new(
+        command_registry: @command_registry,
+        ex_registry: @ex_registry,
+        keymaps: @keymaps,
+        command_host: @command_host,
+        editor: editor,
+        filetype: filetype
+      )
+      code = File.read(path)
+      dsl.instance_eval(code, path, 1)
+      path
+    end
+
+    def load_ftplugin!(editor, buffer)
+      filetype = buffer.options["filetype"].to_s
+      return nil if filetype.empty?
+      return nil if buffer.options["__ftplugin_loaded__"] == filetype
+
+      path = ftplugin_path_for(filetype)
+      return nil unless path && File.file?(path)
+
+      load_file(path, editor:, filetype:)
+      buffer.options["__ftplugin_loaded__"] = filetype
+      path
+    end
+
+    private
+
+    def xdg_config_path
+      base = ::ENV["XDG_CONFIG_HOME"]
+      if base && !base.empty?
+        File.join(base, "ruvim", "init.rb")
+      else
+        File.expand_path("~/.config/ruvim/init.rb")
+      end
+    end
+
+    def ftplugin_path_for(filetype)
+      xdg_ftplugin_path(filetype)
+    end
+
+    def xdg_ftplugin_path(filetype)
+      base = ::ENV["XDG_CONFIG_HOME"]
+      if base && !base.empty?
+        File.join(base, "ruvim", "ftplugin", "#{filetype}.rb")
+      else
+        File.expand_path("~/.config/ruvim/ftplugin/#{filetype}.rb")
+      end
+    end
+  end
+end

data/lib/ruvim/context.rb

@@ -0,0 +1,26 @@
+module RuVim
+  class Context
+    attr_reader :editor, :invocation
+
+    def initialize(editor:, invocation: nil)
+      @editor = editor
+      @invocation = invocation
+    end
+
+    def window
+      editor.current_window
+    end
+
+    def buffer
+      editor.current_buffer
+    end
+
+    def count
+      invocation&.count || 1
+    end
+
+    def bang?
+      invocation&.bang || false
+    end
+  end
+end

data/lib/ruvim/dispatcher.rb

@@ -0,0 +1,120 @@
+require "shellwords"
+
+module RuVim
+  class Dispatcher
+    ExCall = Struct.new(:name, :argv, :bang, keyword_init: true)
+
+    def initialize(command_registry: CommandRegistry.instance, ex_registry: ExCommandRegistry.instance, command_host: GlobalCommands.instance)
+      @command_registry = command_registry
+      @ex_registry = ex_registry
+      @command_host = command_host
+    end
+
+    def dispatch(editor, invocation)
+      spec = @command_registry.fetch(invocation.id)
+      ctx = Context.new(editor:, invocation:)
+      @command_host.call(spec.call, ctx, argv: invocation.argv, kwargs: invocation.kwargs, bang: invocation.bang, count: invocation.count)
+    rescue StandardError => e
+      editor.echo_error("Error: #{e.message}")
+    end
+
+    def dispatch_ex(editor, line)
+      if (sub = parse_global_substitute(line))
+        invocation = CommandInvocation.new(id: "__substitute__", kwargs: sub)
+        ctx = Context.new(editor:, invocation:)
+        @command_host.ex_substitute(ctx, **sub)
+        editor.enter_normal_mode
+        return
+      end
+
+      parsed = parse_ex(line)
+      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)
+      ctx = Context.new(editor:, invocation:)
+      @command_host.call(spec.call, ctx, argv: parsed.argv, bang: parsed.bang, count: 1, kwargs: {})
+    rescue StandardError => e
+      editor.echo_error("Error: #{e.message}")
+    ensure
+      editor.enter_normal_mode
+    end
+
+    def parse_ex(line)
+      raw = line.to_s.strip
+      return nil if raw.empty?
+
+      tokens = Shellwords.shellsplit(raw)
+      return nil if tokens.empty?
+
+      head = tokens.shift
+      bang = head.end_with?("!")
+      name = bang ? head[0...-1] : head
+      ExCall.new(name:, argv: tokens, bang:)
+    rescue ArgumentError => e
+      raise RuVim::CommandError, "Parse error: #{e.message}"
+    end
+
+    def parse_global_substitute(line)
+      raw = line.to_s.strip
+      return nil unless raw.start_with?("%s")
+      return nil if raw.length < 4
+
+      delim = raw[2]
+      return nil if delim.nil? || delim =~ /\s/
+      i = 3
+      pat, i = parse_delimited_segment(raw, i, delim)
+      return nil unless pat
+      rep, i = parse_delimited_segment(raw, i, delim)
+      return nil unless rep
+      flags = raw[i..].to_s
+      {
+        pattern: pat,
+        replacement: rep,
+        global: flags.include?("g")
+      }
+    rescue StandardError
+      nil
+    end
+
+    private
+
+    def parse_delimited_segment(str, idx, delim)
+      out = +""
+      i = idx
+      while i < str.length
+        ch = str[i]
+        if ch == "\\"
+          nxt = str[i + 1]
+          return nil unless nxt
+          out << "\\"
+          out << nxt
+          i += 2
+          next
+        end
+        if ch == delim
+          return [out, i + 1]
+        end
+        out << ch
+        i += 1
+      end
+      nil
+    end
+
+    def validate_ex_args!(spec, argv, bang)
+      case spec.nargs
+      when 0
+        raise RuVim::CommandError, "#{spec.name} takes no arguments" unless argv.empty?
+      when 1
+        raise RuVim::CommandError, "#{spec.name} requires one argument" unless argv.length == 1
+      when :maybe_one
+        raise RuVim::CommandError, "#{spec.name} takes at most one argument" unless argv.length <= 1
+      end
+
+      if bang && !spec.bang
+        raise RuVim::CommandError, "#{spec.name} does not accept !"
+      end
+    end
+  end
+end

data/lib/ruvim/display_width.rb

@@ -0,0 +1,110 @@
+module RuVim
+  module DisplayWidth
+    module_function
+
+    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
+
+      code = ch.ord
+      return 0 if code.zero?
+      return 0 if combining_mark?(code)
+      return 0 if zero_width_codepoint?(code)
+      return ambiguous_width if ambiguous_codepoint?(code)
+      return 2 if emoji_codepoint?(code)
+      return 2 if wide_codepoint?(code)
+
+      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) ||
+        (0x1DC0..0x1DFF).cover?(code) ||
+        (0x20D0..0x20FF).cover?(code) ||
+        (0xFE20..0xFE2F).cover?(code)
+    end
+
+    def zero_width_codepoint?(code)
+      (0x200D..0x200D).cover?(code) || # ZWJ
+        (0xFE00..0xFE0F).cover?(code) || # variation selectors
+        (0xE0100..0xE01EF).cover?(code)  # variation selectors supplement
+    end
+
+    def wide_codepoint?(code)
+      (0x1100..0x115F).cover?(code) ||
+        (0x2329..0x232A).cover?(code) ||
+        (0x2E80..0xA4CF).cover?(code) ||
+        (0xAC00..0xD7A3).cover?(code) ||
+        (0xF900..0xFAFF).cover?(code) ||
+        (0xFE10..0xFE19).cover?(code) ||
+        (0xFE30..0xFE6F).cover?(code) ||
+        (0xFF00..0xFF60).cover?(code) ||
+        (0xFFE0..0xFFE6).cover?(code)
+    end
+
+    def emoji_codepoint?(code)
+      (0x1F300..0x1FAFF).cover?(code) ||
+        (0x2600..0x27BF).cover?(code)
+    end
+
+    def ambiguous_codepoint?(code)
+      (0x00A1..0x00A1).cover?(code) ||
+        (0x00A4..0x00A4).cover?(code) ||
+        (0x00A7..0x00A8).cover?(code) ||
+        (0x00AA..0x00AA).cover?(code) ||
+        (0x00AD..0x00AE).cover?(code) ||
+        (0x00B0..0x00B4).cover?(code) ||
+        (0x00B6..0x00BA).cover?(code) ||
+        (0x00BC..0x00BF).cover?(code) ||
+        (0x0391..0x03A9).cover?(code) ||
+        (0x03B1..0x03C9).cover?(code) ||
+        (0x2010..0x2010).cover?(code) ||
+        (0x2013..0x2016).cover?(code) ||
+        (0x2018..0x2019).cover?(code) ||
+        (0x201C..0x201D).cover?(code) ||
+        (0x2020..0x2022).cover?(code) ||
+        (0x2024..0x2027).cover?(code) ||
+        (0x2030..0x2030).cover?(code) ||
+        (0x2032..0x2033).cover?(code) ||
+        (0x2035..0x2035).cover?(code) ||
+        (0x203B..0x203B).cover?(code) ||
+        (0x203E..0x203E).cover?(code) ||
+        (0x2460..0x24E9).cover?(code) ||
+        (0x2500..0x257F).cover?(code)
+    end
+
+    def ambiguous_width
+      env = ::ENV["RUVIM_AMBIGUOUS_WIDTH"]
+      return 2 if env == "2"
+
+      1
+    end
+  end
+end