ruvim 0.4.0 → 0.6.0

data/lib/ruvim/keymap_manager.rb

@@ -14,7 +14,7 @@ module RuVim
 
     def bind(mode, seq, id, argv: [], kwargs: {}, bang: false)
       tokens = normalize_seq(seq)
-      @mode_maps[mode.to_sym][tokens] = build_invocation(id, argv:, kwargs:, bang:, tokens:)
+      @mode_maps[mode][tokens] = build_invocation(id, argv:, kwargs:, bang:, tokens:)
     end
 
     def bind_global(seq, id, argv: [], kwargs: {}, bang: false)
@@ -29,20 +29,20 @@ module RuVim
 
     def bind_filetype(filetype, seq, id, mode: :normal, argv: [], kwargs: {}, bang: false)
       tokens = normalize_seq(seq)
-      @filetype_maps[filetype.to_s][mode.to_sym][tokens] = build_invocation(id, argv:, kwargs:, bang:, tokens:)
+      @filetype_maps[filetype.to_s][mode][tokens] = build_invocation(id, argv:, kwargs:, bang:, tokens:)
     end
 
     def resolve(mode, pending_tokens)
-      resolve_layers([@mode_maps[mode.to_sym]], pending_tokens)
+      resolve_layers([@mode_maps[mode]], pending_tokens)
     end
 
     def resolve_with_context(mode, pending_tokens, editor:)
       buffer = editor.current_buffer
       filetype = detect_filetype(buffer)
       layers = []
-      layers << @filetype_maps[filetype][mode.to_sym] if filetype && @filetype_maps.key?(filetype)
+      layers << @filetype_maps[filetype][mode] if filetype && @filetype_maps.key?(filetype)
       layers << @buffer_maps[buffer.id] if @buffer_maps.key?(buffer.id)
-      layers << @mode_maps[mode.to_sym]
+      layers << @mode_maps[mode]
       layers << @global_map
       resolve_layers(layers, pending_tokens)
     end
@@ -135,7 +135,7 @@ module RuVim
     def normalized_mode_filter(mode)
       return nil if mode.nil?
 
-      ary = Array(mode).compact.map { |m| m.to_sym }
+      ary = Array(mode).compact
       ary.empty? ? nil : ary
     end
 
@@ -153,7 +153,7 @@ module RuVim
         operator_pending: 5,
         command_line: 6
       }
-      [order.fetch(mode.to_sym, 99), mode.to_s]
+      [order.fetch(mode, 99), mode.to_s]
     end
 
     def detect_filetype(buffer)

data/lib/ruvim/lang/base.rb

@@ -21,5 +21,10 @@ module RuVim
         # no-op
       end
     end
+
+    # Non-highlighted filetypes (extension-only detection)
+    Registry.register("text", mod: Base, extensions: %w[.txt])
+    Registry.register("css", mod: Base, extensions: %w[.css])
+    Registry.register("erlang", mod: Base, extensions: %w[.erl])
   end
 end

data/lib/ruvim/lang/c.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module RuVim
+  module Lang
+    module C
+      KEYWORDS = %w[
+        if else for while return struct enum typedef switch case break
+        continue do static const extern unsigned signed sizeof union
+        goto default volatile register inline restrict
+      ].freeze
+
+      TYPES = %w[
+        int char float double long short void size_t
+        uint8_t uint16_t uint32_t uint64_t
+        int8_t int16_t int32_t int64_t
+        ssize_t ptrdiff_t intptr_t uintptr_t
+        bool FILE
+      ].freeze
+
+      ALL_KEYWORDS = (KEYWORDS + TYPES).uniq.freeze
+
+      KEYWORD_RE = /\b(?:#{ALL_KEYWORDS.join("|")})\b/
+      STRING_RE = /"(?:\\.|[^"\\])*"/
+      CHAR_RE = /'(?:\\.|[^'\\])'/
+      NUMBER_RE = /\b(?:0[xX][0-9a-fA-F]+|0[bB][01]+|\d+(?:\.\d+)?(?:[eE][+-]?\d+)?)[fFlLuU]*\b/
+      LINE_COMMENT_RE = %r{//.*}
+      BLOCK_COMMENT_RE = %r{/\*.*?\*/}
+      PREPROCESSOR_RE = /\A\s*#\s*\w+.*/
+      CONSTANT_RE = /\b[A-Z][A-Z0-9_]{1,}\b/
+
+      INDENT_OPEN_RE = /\{\s*$/
+      INDENT_CLOSE_RE = /\A\s*\}/
+      CASE_RE = /\A\s*(?:case\b.*:|default\s*:)/
+
+      DEDENT_TRIGGERS = {
+        "}" => /\A(\s*)\}/
+      }.freeze
+
+      module_function
+
+      def calculate_indent(lines, target_row, shiftwidth)
+        depth = 0
+        (0...target_row).each do |row|
+          line = lines[row].to_s
+          line.each_char do |ch|
+            case ch
+            when "{" then depth += 1
+            when "}" then depth -= 1
+            end
+          end
+        end
+
+        target_line = lines[target_row].to_s.lstrip
+        depth -= 1 if target_line.match?(INDENT_CLOSE_RE)
+        depth -= 1 if target_line.match?(CASE_RE) && depth > 0
+        depth = 0 if depth < 0
+        depth * shiftwidth
+      end
+
+      def indent_trigger?(line)
+        line.to_s.rstrip.match?(INDENT_OPEN_RE)
+      end
+
+      def dedent_trigger(char)
+        DEDENT_TRIGGERS[char]
+      end
+
+      def on_save(ctx, path)
+        return unless path && File.exist?(path)
+        return if ctx.editor.respond_to?(:restricted_mode?) && ctx.editor.restricted_mode?
+
+        gcc = ENV["CC"] || "gcc"
+        begin
+          output, status = Open3.capture2e(gcc, "-fsyntax-only", "-Wall", path)
+        rescue Errno::ENOENT
+          return
+        end
+
+        if !status.success?
+          buffer_id = ctx.buffer.id
+          items = output.lines.filter_map { |line|
+            if line =~ /\A.+?:(\d+):\d+:/
+              { buffer_id: buffer_id, row: $1.to_i - 1, col: 0, text: line.strip }
+            end
+          }
+          items = [{ buffer_id: buffer_id, row: 0, col: 0, text: output.strip }] if items.empty?
+          ctx.editor.set_quickfix_list(items)
+          first = output.lines.first.to_s.strip
+          hint = items.size > 1 ? " (Q to see all, #{items.size} total)" : ""
+          ctx.editor.echo_error("#{first}#{hint}")
+        else
+          ctx.editor.set_quickfix_list([])
+        end
+      end
+
+      def color_columns(text)
+        cols = {}
+        Highlighter.apply_regex(cols, text, CHAR_RE, Highlighter::STRING_COLOR)
+        Highlighter.apply_regex(cols, text, STRING_RE, Highlighter::STRING_COLOR)
+        Highlighter.apply_regex(cols, text, KEYWORD_RE, Highlighter::KEYWORD_COLOR)
+        Highlighter.apply_regex(cols, text, NUMBER_RE, Highlighter::NUMBER_COLOR)
+        Highlighter.apply_regex(cols, text, CONSTANT_RE, Highlighter::CONSTANT_COLOR)
+        Highlighter.apply_regex(cols, text, PREPROCESSOR_RE, "\e[35m")
+        Highlighter.apply_regex(cols, text, BLOCK_COMMENT_RE, Highlighter::COMMENT_COLOR, override: true)
+        Highlighter.apply_regex(cols, text, LINE_COMMENT_RE, Highlighter::COMMENT_COLOR, override: true)
+        cols
+      end
+    end
+
+    Registry.register("c", mod: C,
+      extensions: %w[.c .h],
+      runprg: "gcc -Wall -o /tmp/a.out % && /tmp/a.out")
+  end
+end

data/lib/ruvim/lang/cpp.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module RuVim
+  module Lang
+    module Cpp
+      CPP_KEYWORDS = %w[
+        class namespace template typename virtual override final
+        public private protected friend
+        new delete dynamic_cast static_cast reinterpret_cast const_cast
+        try catch throw noexcept
+        using auto decltype nullptr constexpr consteval constinit
+        concept requires co_await co_return co_yield
+        mutable explicit export
+      ].freeze
+
+      CPP_TYPES = %w[
+        string vector map set list deque array
+        shared_ptr unique_ptr weak_ptr
+        string_view optional variant any
+        wchar_t char8_t char16_t char32_t
+      ].freeze
+
+      ALL_KEYWORDS = (C::ALL_KEYWORDS + CPP_KEYWORDS + CPP_TYPES).uniq.freeze
+
+      KEYWORD_RE = /\b(?:#{ALL_KEYWORDS.join("|")})\b/
+
+      ACCESS_RE = /\A\s*(?:public|private|protected)\s*:/
+
+      module_function
+
+      def calculate_indent(lines, target_row, shiftwidth)
+        depth = 0
+        (0...target_row).each do |row|
+          line = lines[row].to_s
+          line.each_char do |ch|
+            case ch
+            when "{" then depth += 1
+            when "}" then depth -= 1
+            end
+          end
+        end
+
+        target_line = lines[target_row].to_s.lstrip
+        depth -= 1 if target_line.match?(C::INDENT_CLOSE_RE)
+        depth -= 1 if target_line.match?(C::CASE_RE) && depth > 0
+        depth -= 1 if target_line.match?(ACCESS_RE) && depth > 0
+        depth = 0 if depth < 0
+        depth * shiftwidth
+      end
+
+      def indent_trigger?(line)
+        C.indent_trigger?(line)
+      end
+
+      def dedent_trigger(char)
+        C.dedent_trigger(char)
+      end
+
+      def on_save(ctx, path)
+        return unless path && File.exist?(path)
+        return if ctx.editor.respond_to?(:restricted_mode?) && ctx.editor.restricted_mode?
+
+        compiler = ENV["CXX"] || "g++"
+        begin
+          output, status = Open3.capture2e(compiler, "-fsyntax-only", "-Wall", path)
+        rescue Errno::ENOENT
+          return
+        end
+
+        if !status.success?
+          buffer_id = ctx.buffer.id
+          items = output.lines.filter_map { |line|
+            if line =~ /\A.+?:(\d+):\d+:/
+              { buffer_id: buffer_id, row: $1.to_i - 1, col: 0, text: line.strip }
+            end
+          }
+          items = [{ buffer_id: buffer_id, row: 0, col: 0, text: output.strip }] if items.empty?
+          ctx.editor.set_quickfix_list(items)
+          first = output.lines.first.to_s.strip
+          hint = items.size > 1 ? " (Q to see all, #{items.size} total)" : ""
+          ctx.editor.echo_error("#{first}#{hint}")
+        else
+          ctx.editor.set_quickfix_list([])
+        end
+      end
+
+      def color_columns(text)
+        cols = {}
+        Highlighter.apply_regex(cols, text, C::CHAR_RE, Highlighter::STRING_COLOR)
+        Highlighter.apply_regex(cols, text, C::STRING_RE, Highlighter::STRING_COLOR)
+        Highlighter.apply_regex(cols, text, KEYWORD_RE, Highlighter::KEYWORD_COLOR)
+        Highlighter.apply_regex(cols, text, C::NUMBER_RE, Highlighter::NUMBER_COLOR)
+        Highlighter.apply_regex(cols, text, C::CONSTANT_RE, Highlighter::CONSTANT_COLOR)
+        Highlighter.apply_regex(cols, text, C::PREPROCESSOR_RE, "\e[35m")
+        Highlighter.apply_regex(cols, text, C::BLOCK_COMMENT_RE, Highlighter::COMMENT_COLOR, override: true)
+        Highlighter.apply_regex(cols, text, C::LINE_COMMENT_RE, Highlighter::COMMENT_COLOR, override: true)
+        cols
+      end
+    end
+
+    Registry.register("cpp", mod: Cpp,
+      extensions: %w[.cpp .cc .cxx .hpp],
+      runprg: "g++ -Wall -o /tmp/a.out % && /tmp/a.out")
+  end
+end

data/lib/ruvim/lang/csv.rb

@@ -2,6 +2,9 @@
 
 module RuVim
   module Lang
+    Registry.register("csv", mod: Base,
+      extensions: %w[.csv])
+
     module Csv
       module_function
 
@@ -14,5 +17,5 @@ module RuVim
     end
   end
 
-  RichView.register("csv", RichView::TableRenderer, detector: Lang::Csv.method(:detect?))
+  RichView.register(:csv, RichView::TableRenderer, detector: Lang::Csv.method(:detect?))
 end

data/lib/ruvim/lang/diff.rb

@@ -37,5 +37,7 @@ module RuVim
         end
       end
     end
+
+    Registry.register("diff", mod: Diff)
   end
 end

data/lib/ruvim/lang/dockerfile.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module RuVim
+  module Lang
+    module Dockerfile
+      INSTRUCTIONS = %w[
+        FROM AS RUN CMD EXPOSE ENV ADD COPY ENTRYPOINT VOLUME
+        USER WORKDIR ARG ONBUILD STOPSIGNAL HEALTHCHECK SHELL LABEL MAINTAINER
+      ].freeze
+
+      INSTRUCTION_RE = /\A\s*(?:#{INSTRUCTIONS.join("|")})\b/i
+      STRING_DOUBLE_RE = /"(?:\\.|[^"\\])*"/
+      STRING_SINGLE_RE = /'(?:\\.|[^'\\])*'/
+      VARIABLE_RE = /\$\{?[\w]+\}?/
+      COMMENT_RE = /\A\s*#.*/
+      FLAG_RE = /--[\w\-]+=?/
+
+      module_function
+
+      def color_columns(text)
+        cols = {}
+        Highlighter.apply_regex(cols, text, INSTRUCTION_RE, Highlighter::KEYWORD_COLOR)
+        Highlighter.apply_regex(cols, text, FLAG_RE, Highlighter::CONSTANT_COLOR)
+        Highlighter.apply_regex(cols, text, STRING_DOUBLE_RE, Highlighter::STRING_COLOR)
+        Highlighter.apply_regex(cols, text, STRING_SINGLE_RE, Highlighter::STRING_COLOR)
+        Highlighter.apply_regex(cols, text, VARIABLE_RE, Highlighter::VARIABLE_COLOR)
+        Highlighter.apply_regex(cols, text, COMMENT_RE, Highlighter::COMMENT_COLOR, override: true)
+        cols
+      end
+    end
+
+    Registry.register("dockerfile", mod: Dockerfile,
+      basenames: %w[Dockerfile],
+      basename_prefix: "Dockerfile")
+  end
+end

data/lib/ruvim/lang/elixir.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module RuVim
+  module Lang
+    module Elixir
+      KEYWORDS = %w[
+        def defp defmodule defmacro defmacrop defstruct defprotocol defimpl
+        defguard defguardp defdelegate defoverridable defexception
+        do end fn if else unless cond case when with for receive after
+        raise rescue try catch throw
+        import use alias require
+        and or not in
+        true false nil
+        quote unquote
+      ].freeze
+
+      KEYWORD_RE = /\b(?:#{KEYWORDS.join("|")})\b/
+      STRING_DOUBLE_RE = /"(?:\\.|[^"\\])*"/
+      STRING_SINGLE_RE = /'(?:\\.|[^'\\])*'/
+      HEREDOC_RE = /"""/
+      SIGIL_RE = /~[a-zA-Z](?:\(.*?\)|\[.*?\]|\{.*?\}|<.*?>|\/.*?\/|".*?"|\|.*?\|)/
+      ATOM_RE = /:\w+|:"(?:\\.|[^"\\])*"/
+      MODULE_RE = /\b[A-Z]\w*(?:\.[A-Z]\w*)*/
+      NUMBER_RE = /\b(?:0[xXoObB][\da-fA-F_]+|\d[\d_]*(?:\.[\d_]+)?(?:[eE][+-]?\d+)?)\b/
+      COMMENT_RE = /#.*/
+      VARIABLE_RE = /@\w+/
+
+      INDENT_OPEN_RE = /\b(?:do|fn)\s*(?:->)?\s*$/
+      INDENT_CLOSE_RE = /\A\s*end\b/
+      INDENT_MID_RE = /\A\s*(?:else|rescue|catch|after)\b/
+
+      DEDENT_TRIGGERS = {
+        "d" => /\A(\s*)end\z/,
+        "e" => /\A(\s*)(?:else|rescue)\z/,
+        "h" => /\A(\s*)catch\z/,
+        "r" => /\A(\s*)after\z/
+      }.freeze
+
+      module_function
+
+      def calculate_indent(lines, target_row, shiftwidth)
+        depth = 0
+        (0...target_row).each do |row|
+          line = lines[row].to_s.strip
+          next if line.empty? || line.start_with?("#")
+
+          depth += 1 if line.match?(/\b(?:do|fn)\b/) || line.match?(/->$/)
+          depth -= 1 if line.match?(/\Aend\b/)
+        end
+
+        target_line = lines[target_row].to_s.strip
+        depth -= 1 if target_line.match?(INDENT_CLOSE_RE) || target_line.match?(INDENT_MID_RE)
+        depth = 0 if depth < 0
+        depth * shiftwidth
+      end
+
+      def indent_trigger?(line)
+        line.to_s.rstrip.match?(INDENT_OPEN_RE)
+      end
+
+      def dedent_trigger(char)
+        DEDENT_TRIGGERS[char]
+      end
+
+      def color_columns(text)
+        cols = {}
+        Highlighter.apply_regex(cols, text, STRING_DOUBLE_RE, Highlighter::STRING_COLOR)
+        Highlighter.apply_regex(cols, text, STRING_SINGLE_RE, Highlighter::STRING_COLOR)
+        Highlighter.apply_regex(cols, text, ATOM_RE, Highlighter::CONSTANT_COLOR)
+        Highlighter.apply_regex(cols, text, KEYWORD_RE, Highlighter::KEYWORD_COLOR)
+        Highlighter.apply_regex(cols, text, MODULE_RE, Highlighter::CONSTANT_COLOR)
+        Highlighter.apply_regex(cols, text, VARIABLE_RE, Highlighter::VARIABLE_COLOR)
+        Highlighter.apply_regex(cols, text, NUMBER_RE, Highlighter::NUMBER_COLOR)
+        Highlighter.apply_regex(cols, text, SIGIL_RE, Highlighter::STRING_COLOR)
+        Highlighter.apply_regex(cols, text, COMMENT_RE, Highlighter::COMMENT_COLOR, override: true)
+        cols
+      end
+    end
+
+    Registry.register("elixir", mod: Elixir,
+      extensions: %w[.ex .exs],
+      shebangs: %w[elixir iex],
+      runprg: "elixir %")
+  end
+end

data/lib/ruvim/lang/erb.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module RuVim
+  module Lang
+    module Erb
+      ERB_COMMENT_RE = /<%#.*?%>/
+      ERB_TAG_RE = /<%[=\-]?|[-%]?%>/
+
+      module_function
+
+      def color_columns(text)
+        cols = {}
+
+        # First apply HTML highlighting as base
+        Html.color_columns(text).each { |k, v| cols[k] = v }
+
+        # ERB delimiters (<%= %> <% %> <%- -%>)
+        Highlighter.apply_regex(cols, text, ERB_TAG_RE, "\e[35m", override: true)
+
+        # ERB comment tags override everything (including delimiters)
+        Highlighter.apply_regex(cols, text, ERB_COMMENT_RE, Highlighter::COMMENT_COLOR, override: true)
+
+        cols
+      end
+    end
+
+    Registry.register("erb", mod: Erb,
+      extensions: %w[.erb])
+  end
+end

data/lib/ruvim/lang/go.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module RuVim
+  module Lang
+    module Go
+      KEYWORDS = %w[
+        break case chan const continue default defer else fallthrough
+        for func go goto if import interface map package range return
+        select struct switch type var
+        true false nil iota
+      ].freeze
+
+      TYPES = %w[
+        bool byte complex64 complex128 error float32 float64
+        int int8 int16 int32 int64 rune string
+        uint uint8 uint16 uint32 uint64 uintptr any comparable
+      ].freeze
+
+      ALL_KEYWORDS = (KEYWORDS + TYPES).uniq.freeze
+
+      KEYWORD_RE = /\b(?:#{ALL_KEYWORDS.join("|")})\b/
+      STRING_DOUBLE_RE = /"(?:\\.|[^"\\])*"/
+      STRING_RAW_RE = /`[^`]*`/
+      CHAR_RE = /'(?:\\.|[^'\\])'/
+      NUMBER_RE = /\b(?:0[xXoObB][\da-fA-F_]+|\d[\d_]*(?:\.[\d_]+)?(?:[eE][+-]?\d+)?i?)\b/
+      LINE_COMMENT_RE = %r{//.*}
+      BLOCK_COMMENT_RE = %r{/\*.*?\*/}
+      CONSTANT_RE = /\b[A-Z][A-Z0-9_]{1,}\b/
+
+      INDENT_OPEN_RE = /\{\s*(?:\/\/.*)?$/
+      INDENT_CLOSE_RE = /\A\s*\}/
+
+      DEDENT_TRIGGERS = {
+        "}" => /\A(\s*)\}/
+      }.freeze
+
+      module_function
+
+      def calculate_indent(lines, target_row, shiftwidth)
+        depth = 0
+        (0...target_row).each do |row|
+          line = lines[row].to_s
+          line.each_char do |ch|
+            case ch
+            when "{" then depth += 1
+            when "}" then depth -= 1
+            end
+          end
+        end
+
+        target_line = lines[target_row].to_s.lstrip
+        depth -= 1 if target_line.match?(INDENT_CLOSE_RE)
+        depth = 0 if depth < 0
+        depth * shiftwidth
+      end
+
+      def indent_trigger?(line)
+        line.to_s.rstrip.match?(INDENT_OPEN_RE)
+      end
+
+      def dedent_trigger(char)
+        DEDENT_TRIGGERS[char]
+      end
+
+      def color_columns(text)
+        cols = {}
+        Highlighter.apply_regex(cols, text, CHAR_RE, Highlighter::STRING_COLOR)
+        Highlighter.apply_regex(cols, text, STRING_DOUBLE_RE, Highlighter::STRING_COLOR)
+        Highlighter.apply_regex(cols, text, STRING_RAW_RE, Highlighter::STRING_COLOR)
+        Highlighter.apply_regex(cols, text, KEYWORD_RE, Highlighter::KEYWORD_COLOR)
+        Highlighter.apply_regex(cols, text, NUMBER_RE, Highlighter::NUMBER_COLOR)
+        Highlighter.apply_regex(cols, text, CONSTANT_RE, Highlighter::CONSTANT_COLOR)
+        Highlighter.apply_regex(cols, text, BLOCK_COMMENT_RE, Highlighter::COMMENT_COLOR, override: true)
+        Highlighter.apply_regex(cols, text, LINE_COMMENT_RE, Highlighter::COMMENT_COLOR, override: true)
+        cols
+      end
+    end
+
+    Registry.register("go", mod: Go,
+      extensions: %w[.go],
+      runprg: "go run %")
+  end
+end

data/lib/ruvim/lang/html.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RuVim
+  module Lang
+    module Html
+      TAG_RE = /<\/?[\w\-]+/
+      TAG_CLOSE_RE = /\/?>/
+      ATTR_NAME_RE = /\b[\w\-]+(?==)/
+      STRING_DOUBLE_RE = /"(?:[^"\\]|\\.)*"/
+      STRING_SINGLE_RE = /'(?:[^'\\]|\\.)*'/
+      COMMENT_RE = /<!--.*?-->/
+      DOCTYPE_RE = /<!DOCTYPE\b[^>]*/i
+      ENTITY_RE = /&\w+;|&#\d+;|&#x[\da-fA-F]+;/
+
+      module_function
+
+      def color_columns(text)
+        cols = {}
+        Highlighter.apply_regex(cols, text, TAG_RE, Highlighter::KEYWORD_COLOR)
+        Highlighter.apply_regex(cols, text, TAG_CLOSE_RE, Highlighter::KEYWORD_COLOR)
+        Highlighter.apply_regex(cols, text, DOCTYPE_RE, "\e[35m")
+        Highlighter.apply_regex(cols, text, ATTR_NAME_RE, Highlighter::VARIABLE_COLOR)
+        Highlighter.apply_regex(cols, text, STRING_DOUBLE_RE, Highlighter::STRING_COLOR)
+        Highlighter.apply_regex(cols, text, STRING_SINGLE_RE, Highlighter::STRING_COLOR)
+        Highlighter.apply_regex(cols, text, ENTITY_RE, Highlighter::CONSTANT_COLOR)
+        Highlighter.apply_regex(cols, text, COMMENT_RE, Highlighter::COMMENT_COLOR, override: true)
+        cols
+      end
+    end
+
+    Registry.register("html", mod: Html,
+      extensions: %w[.html .htm .xml])
+  end
+end

data/lib/ruvim/lang/javascript.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module RuVim
+  module Lang
+    module Javascript
+      KEYWORDS = %w[
+        async await break case catch class const continue debugger default
+        delete do else export extends finally for from function if import
+        in instanceof let new of return static super switch this throw
+        try typeof var void while with yield
+        true false null undefined NaN Infinity
+      ].freeze
+
+      KEYWORD_RE = /\b(?:#{KEYWORDS.join("|")})\b/
+      STRING_DOUBLE_RE = /"(?:\\.|[^"\\])*"/
+      STRING_SINGLE_RE = /'(?:\\.|[^'\\])*'/
+      TEMPLATE_RE = /`(?:\\.|[^`\\])*`/
+      NUMBER_RE = /\b(?:0[xXoObB][\da-fA-F_]+|\d[\d_]*(?:\.[\d_]+)?(?:[eE][+-]?\d+)?n?)\b/
+      LINE_COMMENT_RE = %r{//.*}
+      BLOCK_COMMENT_RE = %r{/\*.*?\*/}
+      CONSTANT_RE = /\b[A-Z][A-Z0-9_]{1,}\b/
+      REGEX_RE = %r{/(?:\\.|[^/\\])+/[gimsuvy]*}
+
+      INDENT_OPEN_RE = /[{(\[]\s*(?:\/\/.*)?$/
+      INDENT_CLOSE_RE = /\A\s*[}\])]/
+
+      DEDENT_TRIGGERS = {
+        "}" => /\A(\s*)\}/,
+        "]" => /\A(\s*)\]/,
+        ")" => /\A(\s*)\)/
+      }.freeze
+
+      module_function
+
+      def calculate_indent(lines, target_row, shiftwidth)
+        depth = 0
+        (0...target_row).each do |row|
+          line = lines[row].to_s
+          line.each_char do |ch|
+            case ch
+            when "{", "[", "(" then depth += 1
+            when "}", "]", ")" then depth -= 1
+            end
+          end
+        end
+
+        target_line = lines[target_row].to_s.lstrip
+        depth -= 1 if target_line.match?(INDENT_CLOSE_RE)
+        depth = 0 if depth < 0
+        depth * shiftwidth
+      end
+
+      def indent_trigger?(line)
+        line.to_s.rstrip.match?(INDENT_OPEN_RE)
+      end
+
+      def dedent_trigger(char)
+        DEDENT_TRIGGERS[char]
+      end
+
+      def color_columns(text)
+        cols = {}
+        Highlighter.apply_regex(cols, text, STRING_SINGLE_RE, Highlighter::STRING_COLOR)
+        Highlighter.apply_regex(cols, text, STRING_DOUBLE_RE, Highlighter::STRING_COLOR)
+        Highlighter.apply_regex(cols, text, TEMPLATE_RE, Highlighter::STRING_COLOR)
+        Highlighter.apply_regex(cols, text, KEYWORD_RE, Highlighter::KEYWORD_COLOR)
+        Highlighter.apply_regex(cols, text, NUMBER_RE, Highlighter::NUMBER_COLOR)
+        Highlighter.apply_regex(cols, text, CONSTANT_RE, Highlighter::CONSTANT_COLOR)
+        Highlighter.apply_regex(cols, text, BLOCK_COMMENT_RE, Highlighter::COMMENT_COLOR, override: true)
+        Highlighter.apply_regex(cols, text, LINE_COMMENT_RE, Highlighter::COMMENT_COLOR, override: true)
+        cols
+      end
+    end
+
+    Registry.register("javascript", mod: Javascript,
+      extensions: %w[.js .mjs .cjs],
+      aliases: %w[javascriptreact],
+      shebangs: %w[node nodejs deno],
+      runprg: "node %")
+    Registry.register("javascriptreact", mod: Javascript,
+      extensions: %w[.jsx])
+  end
+end

data/lib/ruvim/lang/json.rb

@@ -48,5 +48,11 @@ module RuVim
         cols
       end
     end
+
+    Registry.register("json", mod: Json,
+      extensions: %w[.json],
+      aliases: %w[jsonl])
+    Registry.register("jsonl", mod: Json,
+      extensions: %w[.jsonl])
   end
 end