ruvim 0.1.0

data/lib/ruvim/buffer.rb

@@ -0,0 +1,421 @@
+module RuVim
+  class Buffer
+    attr_reader :id, :kind, :name
+    attr_accessor :path
+    attr_reader :options
+    attr_writer :modified
+
+    def self.from_file(id:, path:)
+      lines =
+        if File.exist?(path)
+          data = decode_text(File.binread(path))
+          split_lines(data)
+        else
+          [""]
+        end
+      new(id:, path:, lines:)
+    end
+
+    def self.split_lines(data)
+      return [""] if data.empty?
+
+      lines = data.split("\n", -1)
+      if data.end_with?("\n")
+        lines.pop
+      end
+      lines = [""] if lines.empty?
+      lines
+    end
+
+    def self.decode_text(bytes)
+      s = bytes.to_s.dup
+      return s 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)
+      end
+
+      utf8.scrub
+    rescue StandardError
+      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
+      @name = name
+      @lines = lines.dup
+      @lines = [""] if @lines.empty?
+      @modified = false
+      @readonly = !!readonly
+      @modifiable = !!modifiable
+      @undo_stack = []
+      @redo_stack = []
+      @change_group_depth = 0
+      @group_before_snapshot = nil
+      @group_changed = false
+      @recording_suspended = false
+      @options = {}
+    end
+
+    def lines
+      @lines
+    end
+
+    def modified?
+      !!@modified
+    end
+
+    def readonly?
+      @readonly
+    end
+
+    def readonly=(value)
+      @readonly = !!value
+    end
+
+    def modifiable?
+      @modifiable
+    end
+
+    def modifiable=(value)
+      @modifiable = !!value
+    end
+
+    def file_buffer?
+      @kind == :file
+    end
+
+    def intro_buffer?
+      @kind == :intro
+    end
+
+    def virtual_buffer?
+      !file_buffer?
+    end
+
+    def display_name
+      @name || @path || "[No Name]"
+    end
+
+    def configure_special!(kind:, name: nil, readonly: true, modifiable: false)
+      @kind = kind.to_sym
+      @name = name
+      @readonly = !!readonly
+      @modifiable = !!modifiable
+      self
+    end
+
+    def become_normal_empty_buffer!
+      @kind = :file
+      @name = nil
+      @path = nil
+      @readonly = false
+      @modifiable = true
+      @lines = [""]
+      @modified = false
+      @undo_stack.clear
+      @redo_stack.clear
+      @change_group_depth = 0
+      @group_before_snapshot = nil
+      @group_changed = false
+      self
+    end
+
+    def can_undo?
+      !@undo_stack.empty?
+    end
+
+    def can_redo?
+      !@redo_stack.empty?
+    end
+
+    def begin_change_group
+      @change_group_depth += 1
+      nil
+    end
+
+    def end_change_group
+      return nil if @change_group_depth.zero?
+
+      @change_group_depth -= 1
+      return nil unless @change_group_depth.zero?
+
+      if @group_changed && @group_before_snapshot
+        @undo_stack << @group_before_snapshot
+        @redo_stack.clear
+      end
+      @group_before_snapshot = nil
+      @group_changed = false
+      nil
+    end
+
+    def undo!
+      close_change_group_if_open
+      return false unless can_undo?
+
+      current = snapshot
+      prev = @undo_stack.pop
+      with_recording_suspended do
+        restore_snapshot(prev)
+      end
+      @redo_stack << current
+      true
+    end
+
+    def redo!
+      close_change_group_if_open
+      return false unless can_redo?
+
+      current = snapshot
+      nxt = @redo_stack.pop
+      with_recording_suspended do
+        restore_snapshot(nxt)
+      end
+      @undo_stack << current
+      true
+    end
+
+    def line_count
+      @lines.length
+    end
+
+    def line_at(row)
+      @lines.fetch(row)
+    end
+
+    def line_length(row)
+      @lines.fetch(row).length
+    end
+
+    def insert_char(row, col, char)
+      record_change_before_mutation!
+      line = @lines.fetch(row)
+      @lines[row] = line.dup.insert(col, char)
+      @modified = true
+    end
+
+    def insert_text(row, col, text)
+      text.each_char do |ch|
+        if ch == "\n"
+          row, col = insert_newline(row, col)
+        else
+          insert_char(row, col, ch)
+          col += 1
+        end
+      end
+      [row, col]
+    end
+
+    def insert_newline(row, col)
+      record_change_before_mutation!
+      line = @lines.fetch(row)
+      head = line[0...col]
+      tail = line[col..] || ""
+      @lines[row] = head
+      @lines.insert(row + 1, tail)
+      @modified = true
+      [row + 1, 0]
+    end
+
+    def backspace(row, col)
+      if col > 0
+        record_change_before_mutation!
+        line = @lines.fetch(row)
+        @lines[row] = line[0...(col - 1)] + line[col..].to_s
+        @modified = true
+        return [row, col - 1]
+      end
+
+      return [row, col] if row.zero?
+
+      record_change_before_mutation!
+      prev = @lines.fetch(row - 1)
+      cur = @lines.fetch(row)
+      new_col = prev.length
+      @lines[row - 1] = prev + cur
+      @lines.delete_at(row)
+      @modified = true
+      [row - 1, new_col]
+    end
+
+    def delete_char(row, col)
+      line = @lines.fetch(row)
+      if col < line.length
+        record_change_before_mutation!
+        @lines[row] = line[0...col] + line[(col + 1)..].to_s
+        @modified = true
+        return true
+      end
+
+      return false if row >= @lines.length - 1
+
+      record_change_before_mutation!
+      @lines[row] = line + @lines[row + 1]
+      @lines.delete_at(row + 1)
+      @modified = true
+      true
+    end
+
+    def delete_line(row)
+      row = [[row, 0].max, @lines.length - 1].min
+      record_change_before_mutation!
+      deleted = @lines.delete_at(row)
+      @lines << "" if @lines.empty?
+      @modified = true
+      deleted
+    end
+
+    def delete_span(start_row, start_col, end_row, end_col)
+      s_row, s_col, e_row, e_col = normalize_span(start_row, start_col, end_row, end_col)
+      return false if s_row == e_row && s_col == e_col
+
+      record_change_before_mutation!
+
+      if s_row == e_row
+        line = @lines.fetch(s_row)
+        @lines[s_row] = line[0...s_col] + line[e_col..].to_s
+      else
+        head = @lines.fetch(s_row)[0...s_col]
+        tail = @lines.fetch(e_row)[e_col..].to_s
+        @lines[s_row] = head + tail
+        (e_row - s_row).times { @lines.delete_at(s_row + 1) }
+      end
+
+      @lines << "" if @lines.empty?
+      @modified = true
+      true
+    end
+
+    def span_text(start_row, start_col, end_row, end_col)
+      s_row, s_col, e_row, e_col = normalize_span(start_row, start_col, end_row, end_col)
+      return "" if s_row == e_row && s_col == e_col
+
+      if s_row == e_row
+        return @lines.fetch(s_row)[s_col...e_col].to_s
+      end
+
+      parts = []
+      parts << @lines.fetch(s_row)[s_col..].to_s
+      ((s_row + 1)...e_row).each { |row| parts << @lines.fetch(row) }
+      parts << @lines.fetch(e_row)[0...e_col].to_s
+      parts.join("\n")
+    end
+
+    def line_block_text(start_row, count = 1)
+      rows = @lines[start_row, count] || []
+      rows.join("\n") + "\n"
+    end
+
+    def insert_lines_at(index, new_lines)
+      lines = Array(new_lines).map(&:to_s)
+      return if lines.empty?
+
+      record_change_before_mutation!
+      idx = [[index, 0].max, @lines.length].min
+      @lines.insert(idx, *lines)
+      @modified = true
+    end
+
+    def replace_all_lines!(new_lines)
+      record_change_before_mutation!
+      @lines = Array(new_lines).map(&:dup)
+      @lines = [""] if @lines.empty?
+      @modified = true
+    end
+
+    def write_to(path = nil)
+      raise RuVim::CommandError, "Buffer is readonly" if readonly?
+
+      target = path || @path
+      raise RuVim::CommandError, "No file name" if target.nil? || target.empty?
+
+      File.binwrite(target, @lines.join("\n"))
+      @path = target
+      @modified = false
+      target
+    end
+
+    def reload_from_file!(path = nil)
+      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)) : ""
+      @lines = self.class.split_lines(data)
+      @path = target
+      @modified = false
+      @undo_stack.clear
+      @redo_stack.clear
+      @change_group_depth = 0
+      @group_before_snapshot = nil
+      @group_changed = false
+      target
+    end
+
+    private
+
+    def normalize_span(start_row, start_col, end_row, end_col)
+      a_before_b = (start_row < end_row) || (start_row == end_row && start_col <= end_col)
+      s_row, s_col, e_row, e_col =
+        if a_before_b
+          [start_row, start_col, end_row, end_col]
+        else
+          [end_row, end_col, start_row, start_col]
+        end
+      [s_row, s_col, e_row, e_col]
+    end
+
+    def close_change_group_if_open
+      return if @change_group_depth.zero?
+
+      @change_group_depth = 1
+      end_change_group
+    end
+
+    def record_change_before_mutation!
+      ensure_modifiable!
+      return if @recording_suspended
+
+      if @change_group_depth.positive?
+        unless @group_changed
+          @group_before_snapshot = snapshot
+          @group_changed = true
+        end
+        return
+      end
+
+      @undo_stack << snapshot
+      @redo_stack.clear
+    end
+
+    def ensure_modifiable!
+      raise RuVim::CommandError, "Buffer is not modifiable" unless modifiable?
+    end
+
+    def snapshot
+      {
+        lines: @lines.map(&:dup),
+        modified: @modified
+      }
+    end
+
+    def restore_snapshot(snap)
+      @lines = snap.fetch(:lines).map(&:dup)
+      @lines = [""] if @lines.empty?
+      @modified = snap.fetch(:modified)
+    end
+
+    def with_recording_suspended
+      prev = @recording_suspended
+      @recording_suspended = true
+      yield
+    ensure
+      @recording_suspended = prev
+    end
+  end
+end

data/lib/ruvim/cli.rb

@@ -0,0 +1,264 @@
+module RuVim
+  class CLI
+    Options = Struct.new(
+      :files,
+      :pre_config_actions,
+      :startup_actions,
+      :clean,
+      :skip_user_config,
+      :config_path,
+      :readonly,
+      :diff_mode,
+      :quickfix_errorfile,
+      :session_file,
+      :no_swap,
+      :nomodifiable,
+      :restricted_mode,
+      :verbose_level,
+      :startup_time_path,
+      :startup_open_layout,
+      :startup_open_count,
+      :show_help,
+      :show_version,
+      keyword_init: true
+    )
+
+    class ParseError < RuVim::Error; end
+
+    def self.run(argv = ARGV, stdin: STDIN, stdout: STDOUT, stderr: STDERR)
+      opts = parse(argv)
+
+      if opts.show_help
+        stdout.write(help_text)
+        return 0
+      end
+
+      if opts.show_version
+        stdout.puts("RuVim #{RuVim::VERSION}")
+        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
+
+      app = RuVim::App.new(
+        path: opts.files.first,
+        paths: opts.files,
+        stdin: stdin,
+        stdout: stdout,
+        pre_config_actions: opts.pre_config_actions,
+        startup_actions: opts.startup_actions,
+        clean: opts.clean,
+        skip_user_config: opts.skip_user_config,
+        config_path: opts.config_path,
+        readonly: opts.readonly,
+        diff_mode: opts.diff_mode,
+        quickfix_errorfile: opts.quickfix_errorfile,
+        session_file: opts.session_file,
+        nomodifiable: opts.nomodifiable,
+        restricted: opts.restricted_mode,
+        verbose_level: opts.verbose_level,
+        verbose_io: stderr,
+        startup_time_path: opts.startup_time_path,
+        startup_open_layout: opts.startup_open_layout,
+        startup_open_count: opts.startup_open_count
+      )
+      app.run
+      0
+    rescue ParseError => e
+      stderr.puts("ruvim: #{e.message}")
+      stderr.puts("Try 'ruvim --help'.")
+      2
+    end
+
+    def self.parse(argv)
+      args = Array(argv).dup
+      opts = Options.new(
+        files: [],
+        pre_config_actions: [],
+        startup_actions: [],
+        clean: false,
+        skip_user_config: false,
+        config_path: nil,
+        readonly: false,
+        diff_mode: false,
+        quickfix_errorfile: nil,
+        session_file: nil,
+        no_swap: false,
+        nomodifiable: false,
+        restricted_mode: false,
+        verbose_level: 0,
+        startup_time_path: nil,
+        startup_open_layout: nil,
+        startup_open_count: nil,
+        show_help: false,
+        show_version: false
+      )
+
+      i = 0
+      stop_options = false
+      while i < args.length
+        arg = args[i]
+        if stop_options
+          opts.files << arg
+          i += 1
+          next
+        end
+
+        case arg
+        when "--"
+          stop_options = true
+        when "--help", "-h"
+          opts.show_help = true
+        when "--version", "-v"
+          opts.show_version = true
+        when "--verbose"
+          opts.verbose_level = [opts.verbose_level.to_i, 1].max
+        when /\A--verbose=(\d+)\z/
+          opts.verbose_level = Regexp.last_match(1).to_i
+        when "--startuptime"
+          i += 1
+          raise ParseError, "--startuptime requires a file path" if i >= args.length
+          opts.startup_time_path = args[i]
+        when "--cmd"
+          i += 1
+          raise ParseError, "--cmd requires an argument" if i >= args.length
+          opts.pre_config_actions << { type: :ex, value: args[i] }
+        when /\A--cmd=(.+)\z/
+          opts.pre_config_actions << { type: :ex, value: Regexp.last_match(1) }
+        when "--clean"
+          opts.clean = true
+        when "-R"
+          opts.readonly = true
+        when "-d"
+          opts.diff_mode = true
+        when "-q"
+          i += 1
+          raise ParseError, "-q requires an errorfile path" if i >= args.length
+          opts.quickfix_errorfile = args[i]
+        when "-S"
+          if i + 1 < args.length && !args[i + 1].start_with?("-")
+            i += 1
+            opts.session_file = args[i]
+          else
+            opts.session_file = "Session.vim"
+          end
+        when "-n"
+          opts.no_swap = true
+        when "-M"
+          opts.nomodifiable = true
+        when "-Z"
+          opts.restricted_mode = true
+        when "-V"
+          opts.verbose_level = [opts.verbose_level.to_i, 1].max
+        when /\A-V(\d+)\z/
+          opts.verbose_level = Regexp.last_match(1).to_i
+        when "-o", "-O", "-p"
+          apply_layout_option(opts, arg, nil)
+        when /\A-(o|O|p)(\d+)\z/
+          apply_layout_option(opts, Regexp.last_match(1), Regexp.last_match(2).to_i)
+        when "-u"
+          i += 1
+          raise ParseError, "-u requires an argument" if i >= args.length
+          apply_u_option(opts, args[i])
+        when /\A-u(.+)\z/
+          apply_u_option(opts, Regexp.last_match(1))
+        when "-c"
+          i += 1
+          raise ParseError, "-c requires an argument" if i >= args.length
+          opts.startup_actions << { type: :ex, value: args[i] }
+        when /\A\+/
+          apply_plus_option(opts, arg)
+        else
+          if arg.start_with?("-")
+            raise ParseError, "unknown option: #{arg}"
+          end
+          opts.files << arg
+        end
+        i += 1
+      end
+
+      opts
+    end
+
+    def self.apply_u_option(opts, value)
+      if value == "NONE"
+        opts.skip_user_config = true
+        opts.config_path = nil
+      else
+        opts.skip_user_config = false
+        opts.config_path = value
+      end
+    end
+    private_class_method :apply_u_option
+
+    def self.apply_plus_option(opts, arg)
+      rest = arg[1..].to_s
+      if rest.empty?
+        opts.startup_actions << { type: :line_end }
+      elsif rest.match?(/\A\d+\z/)
+        opts.startup_actions << { type: :line, value: rest.to_i }
+      else
+        opts.startup_actions << { type: :ex, value: rest }
+      end
+    end
+    private_class_method :apply_plus_option
+
+    def self.apply_layout_option(opts, token, count)
+      layout =
+        case token
+        when "-o", "o" then :horizontal
+        when "-O", "O" then :vertical
+        when "-p", "p" then :tab
+        else
+          raise ParseError, "unknown layout option: #{token}"
+        end
+      opts.startup_open_layout = layout
+      opts.startup_open_count = count
+    end
+    private_class_method :apply_layout_option
+
+    def self.help_text
+      <<~TXT
+        Usage: ruvim [options] [file]
+
+        Options:
+          -h, --help        Show this help
+          -v, --version     Show version
+          --clean           Start without user config and ftplugin
+          -R                Open file readonly (disallow :w on current buffer)
+          -d                Diff mode requested (compat placeholder; not implemented yet)
+          -q {errorfile}    Quickfix startup placeholder (not implemented yet)
+          -S [session]      Session startup placeholder (not implemented yet)
+          -M                Open file unmodifiable (disallow editing; also readonly)
+          -Z                Restricted mode (skip config/ftplugin, disable :ruby)
+          -V[N], --verbose[=N]
+                            Verbose startup/config/command logs to stderr
+          --startuptime FILE
+                            Write startup timing log
+          --cmd {cmd}       Execute Ex command before loading user config
+          -n                No-op (reserved for swap/persistent features compatibility)
+          -o[N]             Open files in horizontal splits
+          -O[N]             Open files in vertical splits
+          -p[N]             Open files in tabs
+          -u {path|NONE}    Use config file path, or disable user config with NONE
+          -c {cmd}          Execute Ex command after startup
+          +{cmd}            Execute Ex command after startup
+          +{line}           Move cursor to line after startup
+          +                 Move cursor to last line after startup
+
+        Examples:
+          ruvim file.txt
+          ruvim +10 file.txt
+          ruvim --cmd 'set number' file.txt
+          ruvim -c 'set number' file.txt
+          ruvim --clean -u NONE
+      TXT
+    end
+  end
+end