ruvim 0.4.0 → 0.6.0

data/lib/ruvim/browser.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module RuVim
+  module Browser
+    ALLOWED_SCHEMES = %w[https http].freeze
+
+    module_function
+
+    def open_url(url)
+      return false unless valid_url?(url)
+
+      backend = detect_backend
+      return false unless backend
+
+      if backend[:type] == :powershell
+        cmd = powershell_encoded_command(backend[:ps_path], url)
+        _, _, status = Open3.capture3(*cmd)
+      else
+        _, _, status = Open3.capture3(*backend[:command], url)
+      end
+      status.success?
+    rescue StandardError
+      false
+    end
+
+    def valid_url?(url)
+      scheme = url.to_s.split(":", 2).first.to_s.downcase
+      ALLOWED_SCHEMES.include?(scheme)
+    end
+
+    def powershell_encoded_command(ps_path, url)
+      # Encode as UTF-16LE Base64 to avoid any command injection via -Command.
+      # This matches the approach used by Node.js "open" package.
+      ps_script = "Start-Process '#{url.gsub("'", "''")}'"
+      encoded = [ps_script.encode("UTF-16LE")].pack("m0")
+      [ps_path, "-NoProfile", "-NonInteractive", "-EncodedCommand", encoded]
+    end
+
+    def detect_backend
+      return { command: %w[open], type: :macos } if command_available?("open") && macos?
+      return { command: %w[xdg-open], type: :xdg } if command_available?("xdg-open") && !wsl?
+      return { command: %w[wslview], type: :wslview } if command_available?("wslview")
+
+      ps_path = powershell_path(wsl_mount_point)
+      if wsl? && File.exist?(ps_path)
+        return { ps_path: ps_path, type: :powershell }
+      end
+
+      nil
+    end
+
+    def powershell_path(mount_point)
+      "#{mount_point}c/Windows/System32/WindowsPowerShell/v1.0/powershell.exe"
+    end
+
+    def wsl_mount_point(config: nil)
+      config ||= begin
+        File.read("/etc/wsl.conf")
+      rescue StandardError
+        nil
+      end
+
+      default = "/mnt/"
+      return default unless config
+
+      config.each_line do |line|
+        stripped = line.strip
+        next if stripped.start_with?("#")
+
+        if stripped.match?(/\Aroot\s*=/)
+          value = stripped.sub(/\Aroot\s*=\s*/, "").strip
+          value += "/" unless value.end_with?("/")
+          return value
+        end
+      end
+
+      default
+    end
+
+    def macos?
+      RUBY_PLATFORM.include?("darwin")
+    end
+
+    def wsl?
+      return @wsl if defined?(@wsl)
+
+      @wsl = begin
+        File.read("/proc/version").include?("microsoft")
+      rescue StandardError
+        false
+      end
+    end
+
+    def reset!
+      @wsl = nil
+    end
+
+    def command_available?(name)
+      system("which", name, out: File::NULL, err: File::NULL)
+    end
+  end
+end

data/lib/ruvim/buffer.rb

@@ -1,29 +1,33 @@
 # frozen_string_literal: true
 
+require_relative "stream"
+
 module RuVim
   class Buffer
     attr_reader :id, :kind, :name
     attr_accessor :path
     attr_reader :options
     attr_writer :modified
-    attr_accessor :stream_state, :loading_state, :follow_backend
+    attr_accessor :stream
 
     def stream_status
-      return nil unless @stream_state
+      @stream&.status
+    end
 
-      if @kind == :stream
-        "stdin/#{@stream_state}"
-      elsif @follow_backend == :inotify
-        "follow/i"
-      else
-        "follow"
-      end
+    def stream_command
+      @stream&.command
     end
+
     attr_accessor :lang_module
 
+    def self.ensure_regular_file!(path)
+      raise RuVim::CommandError, "Not a regular file: #{path}" if File.exist?(path) && !File.file?(path)
+    end
+
     def self.from_file(id:, path:)
+      ensure_regular_file!(path)
       lines =
-        if File.exist?(path)
+        if File.file?(path)
           data = decode_text(File.binread(path))
           split_lines(data)
         else
@@ -44,34 +48,33 @@ module RuVim
     end
 
     def self.decode_text(bytes)
-      s = bytes.to_s.dup
-      return s if s.encoding == Encoding::UTF_8 && s.valid_encoding?
+      s = bytes.to_s
+      return s.dup if s.encoding == Encoding::UTF_8 && s.valid_encoding?
 
       utf8 = s.dup.force_encoding(Encoding::UTF_8)
       return utf8 if utf8.valid_encoding?
 
       ext = Encoding.default_external
       if ext && ext != Encoding::UTF_8
-        return s.dup.force_encoding(ext).encode(Encoding::UTF_8, invalid: :replace, undef: :replace)
+        return utf8.encode(Encoding::UTF_8, invalid: :replace, undef: :replace)
       end
 
       utf8.scrub
     rescue StandardError
-      s.dup.force_encoding(Encoding::UTF_8).scrub
+      bytes.to_s.dup.force_encoding(Encoding::UTF_8).scrub
     end
 
     def initialize(id:, path: nil, lines: [""], kind: :file, name: nil, readonly: false, modifiable: true)
       @id = id
       @path = path
-      @kind = kind.to_sym
+      @kind = kind
       @name = name
       @lines = lines.dup
       @lines = [""] if @lines.empty?
       @modified = false
       @readonly = !!readonly
       @modifiable = !!modifiable
-      @stream_state = nil
-      @loading_state = nil
+      @stream = nil
       @undo_stack = []
       @redo_stack = []
       @change_group_depth = 0
@@ -99,7 +102,7 @@ module RuVim
     end
 
     def modifiable?
-      @modifiable && @loading_state != :live && @stream_state != :live
+      @modifiable && !@stream&.live?
     end
 
     def modifiable=(value)
@@ -123,12 +126,11 @@ module RuVim
     end
 
     def configure_special!(kind:, name: nil, readonly: true, modifiable: false)
-      @kind = kind.to_sym
+      @kind = kind
       @name = name
       @readonly = !!readonly
       @modifiable = !!modifiable
-      @stream_state = nil unless @kind == :stream
-      @loading_state = nil
+      @stream = nil unless @kind == :stream
       self
     end
 
@@ -138,8 +140,7 @@ module RuVim
       @path = nil
       @readonly = false
       @modifiable = true
-      @stream_state = nil
-      @loading_state = nil
+      @stream = nil
       @lines = [""]
       @modified = false
       @undo_stack.clear
@@ -354,18 +355,26 @@ module RuVim
 
     # 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?
+      return [@lines.length - 1, @lines[-1].length] if text.empty?
 
-      parts = chunk.split("\n", -1)
+      parts = text.split("\n", -1)
       head = parts.shift || ""
-      @lines[-1] = @lines[-1].to_s + head
+      @lines[-1] = @lines[-1] + head
       @lines.concat(parts)
       @lines = [""] if @lines.empty?
       @modified = false
       [@lines.length - 1, @lines[-1].length]
     end
 
+    # Append pre-split lines (from background thread).
+    # head_suffix is concatenated to the current last line.
+    def append_stream_lines!(head_suffix, lines)
+      @lines[-1] = @lines[-1] + head_suffix unless head_suffix.empty?
+      @lines.concat(lines) unless lines.empty?
+      @lines = [""] if @lines.empty?
+      @modified = false
+    end
+
     def finalize_async_file_load!(ended_with_newline:)
       if ended_with_newline && @lines.length > 1 && @lines[-1] == ""
         @lines.pop
@@ -391,7 +400,9 @@ module RuVim
       target = path || @path
       raise RuVim::CommandError, "No file name" if target.nil? || target.empty?
 
-      data = File.exist?(target) ? self.class.decode_text(File.binread(target)) : ""
+      self.class.ensure_regular_file!(target)
+
+      data = File.file?(target) ? self.class.decode_text(File.binread(target)) : ""
       @lines = self.class.split_lines(data)
       @path = target
       @modified = false

data/lib/ruvim/command_invocation.rb

@@ -4,12 +4,12 @@ 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)
+    def initialize(id:, argv: nil, kwargs: nil, count: nil, bang: false, raw_keys: nil)
       @id = id
       @argv = argv || []
       @kwargs = kwargs || {}
       @count = count
-      @bang = !!bang
+      @bang = bang
       @raw_keys = raw_keys
     end
   end