ruvim 0.1.0 → 0.3.0

data/lib/ruvim/buffer.rb

@@ -1,9 +1,13 @@
+# frozen_string_literal: true
+
 module RuVim
   class Buffer
     attr_reader :id, :kind, :name
     attr_accessor :path
     attr_reader :options
     attr_writer :modified
+    attr_accessor :stream_state, :loading_state
+    attr_accessor :lang_module
 
     def self.from_file(id:, path:)
       lines =
@@ -54,12 +58,15 @@ module RuVim
       @modified = false
       @readonly = !!readonly
       @modifiable = !!modifiable
+      @stream_state = nil
+      @loading_state = nil
       @undo_stack = []
       @redo_stack = []
       @change_group_depth = 0
       @group_before_snapshot = nil
       @group_changed = false
       @recording_suspended = false
+      @lang_module = Lang::Base
       @options = {}
     end
 
@@ -80,7 +87,7 @@ module RuVim
     end
 
     def modifiable?
-      @modifiable
+      @modifiable && @loading_state != :live
     end
 
     def modifiable=(value)
@@ -108,6 +115,8 @@ module RuVim
       @name = name
       @readonly = !!readonly
       @modifiable = !!modifiable
+      @stream_state = nil unless @kind == :stream
+      @loading_state = nil
       self
     end
 
@@ -117,6 +126,8 @@ module RuVim
       @path = nil
       @readonly = false
       @modifiable = true
+      @stream_state = nil
+      @loading_state = nil
       @lines = [""]
       @modified = false
       @undo_stack.clear
@@ -329,6 +340,29 @@ module RuVim
       @modified = true
     end
 
+    # Append externally-streamed text without touching undo history or modifiable state.
+    def append_stream_text!(text)
+      chunk = text.to_s
+      return [@lines.length - 1, @lines[-1].length] if chunk.empty?
+
+      parts = chunk.split("\n", -1)
+      head = parts.shift || ""
+      @lines[-1] = @lines[-1].to_s + head
+      @lines.concat(parts)
+      @lines = [""] if @lines.empty?
+      @modified = false
+      [@lines.length - 1, @lines[-1].length]
+    end
+
+    def finalize_async_file_load!(ended_with_newline:)
+      if ended_with_newline && @lines.length > 1 && @lines[-1] == ""
+        @lines.pop
+      end
+      @lines = [""] if @lines.empty?
+      @modified = false
+      self
+    end
+
     def write_to(path = nil)
       raise RuVim::CommandError, "Buffer is readonly" if readonly?
 

data/lib/ruvim/cli.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RuVim
   class CLI
     Options = Struct.new(
@@ -38,18 +40,25 @@ module RuVim
         return 0
       end
 
-      if opts.files.length > 1 && opts.startup_open_layout.nil?
-        raise ParseError, "multiple files are not supported yet"
-      end
 
       if opts.config_path && !File.file?(opts.config_path)
         raise ParseError, "config file not found: #{opts.config_path}"
       end
 
+      ui_stdin = stdin
+      stdin_stream_mode = false
+      if stdin.respond_to?(:tty?) && !stdin.tty?
+        ui_stdin = IO.console
+        raise ParseError, "no controlling terminal available for interactive UI" unless ui_stdin
+        stdin_stream_mode = opts.files.empty?
+      end
+
       app = RuVim::App.new(
         path: opts.files.first,
         paths: opts.files,
         stdin: stdin,
+        ui_stdin: ui_stdin,
+        stdin_stream_mode: stdin_stream_mode,
         stdout: stdout,
         pre_config_actions: opts.pre_config_actions,
         startup_actions: opts.startup_actions,

data/lib/ruvim/clipboard.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "open3"
 
 module RuVim

data/lib/ruvim/command_invocation.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RuVim
   class CommandInvocation
     attr_accessor :id, :argv, :kwargs, :count, :bang, :raw_keys
@@ -6,7 +8,7 @@ module RuVim
       @id = id
       @argv = argv || []
       @kwargs = kwargs || {}
-      @count = count || 1
+      @count = count
       @bang = !!bang
       @raw_keys = raw_keys
     end

data/lib/ruvim/command_line.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RuVim
   class CommandLine
     attr_reader :prefix, :text, :cursor

data/lib/ruvim/command_registry.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RuVim
   class CommandRegistry
     CommandSpec = Struct.new(

data/lib/ruvim/config_dsl.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RuVim
   class ConfigDSL < BasicObject
     def initialize(command_registry:, ex_registry:, keymaps:, command_host:, editor: nil, filetype: nil)

data/lib/ruvim/config_loader.rb

@@ -1,5 +1,9 @@
+# frozen_string_literal: true
+
 module RuVim
   class ConfigLoader
+    SAFE_FILETYPE_RE = /\A[a-zA-Z0-9_+-]+\z/.freeze
+
     def initialize(command_registry:, ex_registry:, keymaps:, command_host:)
       @command_registry = command_registry
       @ex_registry = ex_registry
@@ -32,6 +36,7 @@ module RuVim
       filetype = buffer.options["filetype"].to_s
       return nil if filetype.empty?
       return nil if buffer.options["__ftplugin_loaded__"] == filetype
+      return nil unless safe_filetype_name?(filetype)
 
       path = ftplugin_path_for(filetype)
       return nil unless path && File.file?(path)
@@ -58,11 +63,22 @@ module RuVim
 
     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
+      root =
+        if base && !base.empty?
+          File.join(base, "ruvim", "ftplugin")
+        else
+          File.expand_path("~/.config/ruvim/ftplugin")
+        end
+
+      candidate = File.expand_path(File.join(root, "#{filetype}.rb"))
+      root_prefix = File.join(File.expand_path(root), "")
+      return nil unless candidate.start_with?(root_prefix)
+
+      candidate
+    end
+
+    def safe_filetype_name?(filetype)
+      SAFE_FILETYPE_RE.match?(filetype.to_s)
     end
   end
 end

data/lib/ruvim/context.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RuVim
   class Context
     attr_reader :editor, :invocation
@@ -15,12 +17,5 @@ module RuVim
       editor.current_buffer
     end
 
-    def count
-      invocation&.count || 1
-    end
-
-    def bang?
-      invocation&.bang || false
-    end
   end
 end

data/lib/ruvim/dispatcher.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "shellwords"
 
 module RuVim
@@ -19,26 +21,50 @@ module RuVim
     end
 
     def dispatch_ex(editor, line)
-      if (sub = parse_global_substitute(line))
-        invocation = CommandInvocation.new(id: "__substitute__", kwargs: sub)
+      raw = line.to_s.strip
+      if raw.start_with?("!")
+        command = raw[1..].to_s.strip
+        invocation = CommandInvocation.new(id: "__shell__", argv: [command])
+        ctx = Context.new(editor:, invocation:)
+        @command_host.ex_shell(ctx, command:)
+        editor.enter_normal_mode
+        return
+      end
+
+      # Parse range prefix
+      range_result = parse_range(raw, editor)
+      rest = range_result ? range_result[:rest] : raw
+
+      # Try substitute on rest
+      if (sub = parse_substitute(rest))
+        kwargs = sub.merge(
+          range_start: range_result&.dig(:range_start),
+          range_end: range_result&.dig(:range_end)
+        )
+        invocation = CommandInvocation.new(id: "__substitute__", kwargs:)
         ctx = Context.new(editor:, invocation:)
-        @command_host.ex_substitute(ctx, **sub)
+        @command_host.ex_substitute(ctx, **kwargs)
         editor.enter_normal_mode
         return
       end
 
-      parsed = parse_ex(line)
+      parsed = parse_ex(rest)
       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: {})
+      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)
     rescue StandardError => e
       editor.echo_error("Error: #{e.message}")
     ensure
-      editor.enter_normal_mode
+      editor.leave_command_line if editor.mode == :command_line
     end
 
     def parse_ex(line)
@@ -56,28 +82,142 @@ module RuVim
       raise RuVim::CommandError, "Parse error: #{e.message}"
     end
 
-    def parse_global_substitute(line)
+    # Parse a substitute command: s/pat/repl/flags
+    # Returns {pattern:, replacement:, flags_str:} or nil
+    def parse_substitute(line)
       raw = line.to_s.strip
-      return nil unless raw.start_with?("%s")
-      return nil if raw.length < 4
+      return nil unless raw.match?(/\As[^a-zA-Z]/)
+      return nil if raw.length < 2
 
-      delim = raw[2]
+      delim = raw[1]
       return nil if delim.nil? || delim =~ /\s/
-      i = 3
+      i = 2
       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
+      flags_str = raw[i..].to_s
       {
         pattern: pat,
         replacement: rep,
-        global: flags.include?("g")
+        flags_str: flags_str
       }
     rescue StandardError
       nil
     end
 
+    # Parse an address at position pos in str.
+    # Returns [resolved_line_number, new_pos] or nil.
+    def parse_address(str, pos, editor)
+      return nil if pos >= str.length
+
+      ch = str[pos]
+      base = nil
+      new_pos = pos
+
+      case ch
+      when /\d/
+        # Numeric address
+        m = str[pos..].match(/\A(\d+)/)
+        return nil unless m
+        base = m[1].to_i - 1 # convert 1-based to 0-based
+        new_pos = pos + m[0].length
+      when "."
+        base = editor.current_window.cursor_y
+        new_pos = pos + 1
+      when "$"
+        base = editor.current_buffer.line_count - 1
+        new_pos = pos + 1
+      when "'"
+        # Mark address
+        mark_ch = str[pos + 1]
+        return nil unless mark_ch
+        if mark_ch == "<" || mark_ch == ">"
+          sel = editor.visual_selection
+          if sel
+            base = mark_ch == "<" ? sel[:start_row] : sel[:end_row]
+          else
+            return nil
+          end
+        else
+          loc = editor.mark_location(mark_ch)
+          return nil unless loc
+          base = loc[:row]
+        end
+        new_pos = pos + 2
+      when "+", "-"
+        # Relative offset with implicit current line
+        base = editor.current_window.cursor_y
+        # Don't advance new_pos — the offset parsing below will handle +/-
+      else
+        return nil
+      end
+
+      # Parse trailing +N / -N offsets
+      while new_pos < str.length
+        offset_ch = str[new_pos]
+        if offset_ch == "+"
+          m = str[new_pos + 1..].to_s.match(/\A(\d+)/)
+          if m
+            base += m[1].to_i
+            new_pos += 1 + m[0].length
+          else
+            base += 1
+            new_pos += 1
+          end
+        elsif offset_ch == "-"
+          m = str[new_pos + 1..].to_s.match(/\A(\d+)/)
+          if m
+            base -= m[1].to_i
+            new_pos += 1 + m[0].length
+          else
+            base -= 1
+            new_pos += 1
+          end
+        else
+          break
+        end
+      end
+
+      # Clamp to valid range
+      max_line = editor.current_buffer.line_count - 1
+      base = [[base, 0].max, max_line].min
+
+      [base, new_pos]
+    end
+
+    # 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
+      return nil if str.empty?
+
+      # % = whole file
+      if str[0] == "%"
+        max_line = editor.current_buffer.line_count - 1
+        rest = str[1..].to_s
+        return { range_start: 0, range_end: max_line, rest: rest }
+      end
+
+      # Try first address
+      addr1 = parse_address(str, 0, editor)
+      return nil unless addr1
+
+      line1, pos = addr1
+
+      if pos < str.length && str[pos] == ","
+        # addr,addr range
+        addr2 = parse_address(str, pos + 1, editor)
+        if addr2
+          line2, pos2 = addr2
+          return { range_start: line1, range_end: line2, rest: str[pos2..].to_s }
+        end
+      end
+
+      # Single address
+      { range_start: line1, range_end: line1, rest: str[pos..].to_s }
+    end
+
     private
 
     def parse_delimited_segment(str, idx, delim)

data/lib/ruvim/display_width.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RuVim
   module DisplayWidth
     module_function
@@ -11,6 +13,26 @@ module RuVim
       end
 
       code = ch.ord
+      return 1 if code <= 0xA0 && !code.zero?
+      return cached_codepoint_width(code) if codepoint_cacheable?(code)
+
+      uncached_codepoint_width(code)
+    end
+
+    def codepoint_cacheable?(code)
+      !code.nil? && !code.zero?
+    end
+
+    def cached_codepoint_width(code)
+      aw = ambiguous_width
+      @codepoint_width_cache ||= {}
+      key = [code, aw]
+      return @codepoint_width_cache[key] if @codepoint_width_cache.key?(key)
+
+      @codepoint_width_cache[key] = uncached_codepoint_width(code)
+    end
+
+    def uncached_codepoint_width(code)
       return 0 if code.zero?
       return 0 if combining_mark?(code)
       return 0 if zero_width_codepoint?(code)
@@ -102,9 +124,13 @@ module RuVim
 
     def ambiguous_width
       env = ::ENV["RUVIM_AMBIGUOUS_WIDTH"]
-      return 2 if env == "2"
+      if !defined?(@ambiguous_width_cached) || @ambiguous_width_env != env
+        @ambiguous_width_env = env
+        @ambiguous_width_cached = (env == "2" ? 2 : 1)
+        @codepoint_width_cache = {}
+      end
 
-      1
+      @ambiguous_width_cached
     end
   end
 end