ruvim 0.4.0 → 0.6.0

data/lib/ruvim/lang/lua.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module RuVim
+  module Lang
+    module Lua
+      KEYWORDS = %w[
+        and break do else elseif end false for function goto if in
+        local nil not or repeat return then true until while
+      ].freeze
+
+      KEYWORD_RE = /\b(?:#{KEYWORDS.join("|")})\b/
+      STRING_DOUBLE_RE = /"(?:\\.|[^"\\])*"/
+      STRING_SINGLE_RE = /'(?:\\.|[^'\\])*'/
+      LONG_STRING_RE = /\[\[.*?\]\]/
+      NUMBER_RE = /\b(?:0[xX][\da-fA-F]+(?:\.[\da-fA-F]+)?(?:[pP][+-]?\d+)?|\d+(?:\.\d+)?(?:[eE][+-]?\d+)?)\b/
+      LINE_COMMENT_RE = /--(?!\[\[).*/
+      BLOCK_COMMENT_RE = /--\[\[.*?\]\]/
+      BUILTIN_RE = /\b(?:print|type|tostring|tonumber|pairs|ipairs|next|select|unpack|require|error|assert|pcall|xpcall|setmetatable|getmetatable|rawget|rawset|rawequal|rawlen|table|string|math|io|os|coroutine|debug|package)\b/
+
+      INDENT_OPEN_RE = /\b(?:function|if|for|while|repeat|do|else|elseif)\b/
+      INDENT_CLOSE_RE = /\A\s*(?:end|until)\b/
+      INDENT_MID_RE = /\A\s*(?:else|elseif)\b/
+
+      DEDENT_TRIGGERS = {
+        "d" => /\A(\s*)end\z/,
+        "l" => /\A(\s*)until\z/,
+        "e" => /\A(\s*)(?:else|elseif)\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(?:function|if|for|while|repeat|do)\b/) && !line.match?(/\bend\b/)
+          depth -= 1 if line.match?(/\A(?:end|until)\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)
+        stripped = line.to_s.rstrip
+        stripped.match?(/\b(?:function|if|for|while|repeat|do|then|else)\b/)
+      end
+
+      def dedent_trigger(char)
+        DEDENT_TRIGGERS[char]
+      end
+
+      def color_columns(text)
+        cols = {}
+        Highlighter.apply_regex(cols, text, LONG_STRING_RE, Highlighter::STRING_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, KEYWORD_RE, Highlighter::KEYWORD_COLOR)
+        Highlighter.apply_regex(cols, text, BUILTIN_RE, "\e[35m")
+        Highlighter.apply_regex(cols, text, NUMBER_RE, Highlighter::NUMBER_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("lua", mod: Lua,
+      extensions: %w[.lua],
+      shebangs: ["lua", /\Alua\d*\z/],
+      runprg: "lua %")
+  end
+end

data/lib/ruvim/lang/makefile.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module RuVim
+  module Lang
+    module Makefile
+      TARGET_RE = /\A[\w.\-\/]+\s*:/
+      VARIABLE_DEF_RE = /\A[\w.\-]+\s*[?:+]?=/
+      VARIABLE_REF_RE = /\$[({][\w.\-]+[)}]|\$[A-Za-z@<*^?%]/
+      DIRECTIVE_RE = /\A\s*(?:ifeq|ifneq|ifdef|ifndef|else|endif|define|endef|include|-include|sinclude|override|export|unexport|vpath)\b/
+      FUNCTION_RE = /\$\((?:subst|patsubst|strip|findstring|filter|filter-out|sort|word|wordlist|words|firstword|lastword|dir|notdir|suffix|basename|addsuffix|addprefix|join|wildcard|realpath|abspath|foreach|if|or|and|call|eval|file|value|error|warning|info|shell|origin|flavor|guile)\b/
+      COMMENT_RE = /#.*/
+      STRING_DOUBLE_RE = /"(?:\\.|[^"\\])*"/
+      STRING_SINGLE_RE = /'(?:\\.|[^'\\])*'/
+      AUTO_VAR_RE = /\$[@<*^?%]/
+
+      module_function
+
+      def color_columns(text)
+        cols = {}
+        Highlighter.apply_regex(cols, text, TARGET_RE, "\e[1;33m")
+        Highlighter.apply_regex(cols, text, VARIABLE_DEF_RE, Highlighter::KEYWORD_COLOR)
+        Highlighter.apply_regex(cols, text, DIRECTIVE_RE, Highlighter::KEYWORD_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, FUNCTION_RE, "\e[35m")
+        Highlighter.apply_regex(cols, text, VARIABLE_REF_RE, Highlighter::VARIABLE_COLOR)
+        Highlighter.apply_regex(cols, text, AUTO_VAR_RE, Highlighter::VARIABLE_COLOR)
+        Highlighter.apply_regex(cols, text, COMMENT_RE, Highlighter::COMMENT_COLOR, override: true)
+        cols
+      end
+    end
+
+    Registry.register("make", mod: Makefile,
+      basenames: %w[Makefile GNUmakefile makefile Justfile])
+  end
+end

data/lib/ruvim/lang/markdown.rb

@@ -80,10 +80,6 @@ module RuVim
 
       module_function
 
-      def heading?(line)
-        line.to_s.match?(HEADING_RE)
-      end
-
       def heading_level(line)
         m = line.to_s.match(HEADING_RE)
         m ? m[2].length : 0
@@ -166,5 +162,8 @@ module RuVim
         text.length.times { |i| cols[i] = color }
       end
     end
+
+    Registry.register("markdown", mod: Markdown,
+      extensions: %w[.md])
   end
 end

data/lib/ruvim/lang/ocaml.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module RuVim
+  module Lang
+    module Ocaml
+      KEYWORDS = %w[
+        and as assert begin class constraint do done downto else end
+        exception external false for fun function functor if in include
+        inherit initializer lazy let match method mod module mutable
+        new nonrec object of open or private rec sig struct then to
+        true try type val virtual when while with
+      ].freeze
+
+      KEYWORD_RE = /\b(?:#{KEYWORDS.join("|")})\b/
+      STRING_DOUBLE_RE = /"(?:\\.|[^"\\])*"/
+      CHAR_RE = /'(?:\\.|[^'\\])'/
+      NUMBER_RE = /\b(?:0[xXoObB][\da-fA-F_]+|\d[\d_]*(?:\.[\d_]+)?(?:[eE][+-]?\d+)?)\b/
+      BLOCK_COMMENT_RE = /\(\*.*?\*\)/
+      MODULE_RE = /\b[A-Z]\w*(?:\.[A-Z]\w*)*/
+      VARIANT_RE = /\b[A-Z]\w*\b/
+      TYPE_VAR_RE = /'\w+/
+      OPERATOR_RE = /->|::|;;|<-|\|>/
+
+      INDENT_OPEN_RE = /\b(?:struct|sig|begin|do|then|else)\s*$/
+      INDENT_CLOSE_RE = /\A\s*(?:end|done)\b/
+
+      DEDENT_TRIGGERS = {
+        "d" => /\A(\s*)end\z/,
+        "e" => /\A(\s*)(?:done|else)\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?
+
+          depth += 1 if line.match?(/\b(?:struct|sig|begin|do)\b/)
+          depth -= 1 if line.match?(/\A(?:end|done)\b/)
+        end
+
+        target_line = lines[target_row].to_s.strip
+        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, KEYWORD_RE, Highlighter::KEYWORD_COLOR)
+        Highlighter.apply_regex(cols, text, TYPE_VAR_RE, Highlighter::VARIABLE_COLOR)
+        Highlighter.apply_regex(cols, text, MODULE_RE, Highlighter::CONSTANT_COLOR)
+        Highlighter.apply_regex(cols, text, NUMBER_RE, Highlighter::NUMBER_COLOR)
+        Highlighter.apply_regex(cols, text, OPERATOR_RE, Highlighter::KEYWORD_COLOR)
+        Highlighter.apply_regex(cols, text, BLOCK_COMMENT_RE, Highlighter::COMMENT_COLOR, override: true)
+        cols
+      end
+    end
+
+    Registry.register("ocaml", mod: Ocaml,
+      extensions: %w[.ml .mli],
+      shebangs: %w[ocaml],
+      runprg: "ocaml %")
+  end
+end

data/lib/ruvim/lang/perl.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module RuVim
+  module Lang
+    module Perl
+      KEYWORDS = %w[
+        my our local sub return if elsif else unless while until for
+        foreach do given when default last next redo goto
+        use require package no BEGIN END
+        die warn print say chomp chop push pop shift unshift
+        open close read write seek tell
+        map grep sort reverse join split
+        defined undef delete exists ref bless
+        eval try catch finally
+        and or not xor
+        eq ne lt gt le ge cmp
+      ].freeze
+
+      KEYWORD_RE = /\b(?:#{KEYWORDS.join("|")})\b/
+      STRING_DOUBLE_RE = /"(?:\\.|[^"\\])*"/
+      STRING_SINGLE_RE = /'(?:\\.|[^'\\])*'/
+      REGEX_RE = %r{(?<=[=~(,;\s])(?:m|s|tr|y)?/(?:\\.|[^/\\])*/[gimxsecpodualn]*}
+      QW_RE = /\bqw\s*[({<\/|].*?[)}>\/|]/
+      SCALAR_RE = /\$[\w]+/
+      ARRAY_RE = /@[\w]+/
+      HASH_RE = /%[\w]+/
+      SPECIAL_VAR_RE = /\$[_!@&`'+\\\/\-\[\]]/
+      NUMBER_RE = /\b(?:0[xXoObB][\da-fA-F_]+|\d[\d_]*(?:\.[\d_]+)?(?:[eE][+-]?\d+)?)\b/
+      COMMENT_RE = /#.*/
+      POD_RE = /\A=[a-zA-Z]\w*/
+
+      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 = {}
+        # POD documentation
+        if text.match?(POD_RE)
+          text.length.times { |i| cols[i] = Highlighter::COMMENT_COLOR }
+          return cols
+        end
+        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, KEYWORD_RE, Highlighter::KEYWORD_COLOR)
+        Highlighter.apply_regex(cols, text, SCALAR_RE, Highlighter::VARIABLE_COLOR)
+        Highlighter.apply_regex(cols, text, ARRAY_RE, "\e[35m")
+        Highlighter.apply_regex(cols, text, HASH_RE, Highlighter::CONSTANT_COLOR)
+        Highlighter.apply_regex(cols, text, NUMBER_RE, Highlighter::NUMBER_COLOR)
+        Highlighter.apply_regex(cols, text, COMMENT_RE, Highlighter::COMMENT_COLOR, override: true)
+        cols
+      end
+    end
+
+    Registry.register("perl", mod: Perl,
+      extensions: %w[.pl .pm .t],
+      shebangs: [/\Aperl(?:\d+(?:\.\d+)*)?\z/],
+      runprg: "perl %")
+  end
+end

data/lib/ruvim/lang/python.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module RuVim
+  module Lang
+    module Python
+      KEYWORDS = %w[
+        and as assert async await break class continue def del elif else
+        except finally for from global if import in is lambda nonlocal
+        not or pass raise return try while with yield
+        True False None
+      ].freeze
+
+      KEYWORD_RE = /\b(?:#{KEYWORDS.join("|")})\b/
+      STRING_TRIPLE_DQ_RE = /""".*?"""/m
+      STRING_TRIPLE_SQ_RE = /'''.*?'''/m
+      STRING_DOUBLE_RE = /"(?:\\.|[^"\\])*"/
+      STRING_SINGLE_RE = /'(?:\\.|[^'\\])*'/
+      FSTRING_PREFIX_RE = /[fFrRbBuU]{1,2}(?=["'])/
+      NUMBER_RE = /\b(?:0[xXoObB][\da-fA-F_]+|\d[\d_]*(?:\.[\d_]+)?(?:[eE][+-]?\d+)?j?)\b/
+      DECORATOR_RE = /@[\w.]+/
+      COMMENT_RE = /#.*/
+      CONSTANT_RE = /\b[A-Z][A-Z0-9_]{1,}\b/
+      BUILTIN_RE = /\b(?:print|len|range|type|int|str|float|list|dict|tuple|set|bool|open|input|map|filter|zip|enumerate|sorted|reversed|super|isinstance|issubclass|hasattr|getattr|setattr|delattr|property|staticmethod|classmethod|__\w+__)\b/
+
+      INDENT_OPEN_RE = /:\s*(?:#.*)?$/
+      INDENT_CLOSE_RE = /\A\s*(?:return|break|continue|pass|raise)\b/
+
+      DEDENT_TRIGGERS = {
+        "s" => /\A(\s*)(?:else|class)\z/,
+        ":" => /\A(\s*)(?:else|elif|except|finally)\s*.*:\z/,
+        "f" => /\A(\s*)elif\z/
+      }.freeze
+
+      module_function
+
+      def calculate_indent(lines, target_row, shiftwidth)
+        return 0 if target_row == 0
+
+        prev_row = target_row - 1
+        prev_row -= 1 while prev_row > 0 && lines[prev_row].to_s.strip.empty?
+        prev = lines[prev_row].to_s
+        prev_indent = prev[/\A */].size
+
+        if prev.rstrip.match?(INDENT_OPEN_RE)
+          return prev_indent + shiftwidth
+        end
+
+        target_line = lines[target_row].to_s.strip
+        if target_line.match?(/\A(?:else|elif|except|finally)\b/)
+          depth = prev_indent - shiftwidth
+          return depth < 0 ? 0 : depth
+        end
+
+        prev_indent
+      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, FSTRING_PREFIX_RE, Highlighter::STRING_COLOR)
+        Highlighter.apply_regex(cols, text, KEYWORD_RE, Highlighter::KEYWORD_COLOR)
+        Highlighter.apply_regex(cols, text, BUILTIN_RE, "\e[35m")
+        Highlighter.apply_regex(cols, text, DECORATOR_RE, "\e[35m")
+        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, COMMENT_RE, Highlighter::COMMENT_COLOR, override: true)
+        cols
+      end
+    end
+
+    Registry.register("python", mod: Python,
+      extensions: %w[.py],
+      shebangs: [/\Apython(?:\d+(?:\.\d+)*)?\z/],
+      runprg: "python3 %")
+  end
+end

data/lib/ruvim/lang/registry.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module RuVim
+  module Lang
+    # Central registry for language modules.
+    # Each lang module registers itself at load time via Lang.register.
+    module Registry
+      @entries = {}
+
+      class << self
+        # Register a language module.
+        #
+        # @param filetype [String] primary filetype name (e.g. "ruby")
+        # @param mod [Module] the lang module (must respond to :color_columns)
+        # @param extensions [Array<String>] file extensions including dot (e.g. [".rb", ".rake"])
+        # @param basenames [Array<String>] exact basenames (e.g. ["Makefile"])
+        # @param basename_prefix [String, nil] prefix match for basename (e.g. "Dockerfile")
+        # @param shebangs [Array<String, Regexp>] shebang command matchers
+        # @param aliases [Array<String>] additional filetype names that map to the same module
+        # @param runprg [String, nil] default run command (% = filename)
+        def register(filetype, mod:, extensions: [], basenames: [], basename_prefix: nil,
+                     shebangs: [], aliases: [], runprg: nil)
+          entry = {
+            filetype: filetype,
+            mod: mod,
+            extensions: extensions,
+            basenames: basenames,
+            basename_prefix: basename_prefix,
+            shebangs: shebangs,
+            aliases: aliases,
+            runprg: runprg
+          }.freeze
+          @entries[filetype] = entry
+          aliases.each { |a| @entries[a] = entry }
+        end
+
+        # Look up a lang module by filetype string.
+        # Returns the module or Lang::Base if not found.
+        def resolve_module(ft)
+          entry = @entries[ft]
+          entry ? entry[:mod] : Lang::Base
+        end
+
+        # Look up runprg by filetype string. Returns nil if not registered.
+        def runprg_for(ft)
+          entry = @entries[ft]
+          entry&.[](:runprg)
+        end
+
+        # Detect filetype from file extension.
+        # Returns filetype string or nil.
+        def detect_by_extension(ext)
+          ext = ext.downcase
+          @entries.each_value do |entry|
+            return entry[:filetype] if entry[:extensions].include?(ext)
+          end
+          nil
+        end
+
+        # Detect filetype from exact basename.
+        # Returns filetype string or nil.
+        def detect_by_basename(basename)
+          @entries.each_value do |entry|
+            return entry[:filetype] if entry[:basenames].include?(basename)
+          end
+          # Prefix match
+          @entries.each_value do |entry|
+            prefix = entry[:basename_prefix]
+            return entry[:filetype] if prefix && basename.start_with?(prefix)
+          end
+          nil
+        end
+
+        # Detect filetype from shebang command name.
+        # Returns filetype string or nil.
+        def detect_by_shebang(cmd)
+          @entries.each_value do |entry|
+            entry[:shebangs].each do |matcher|
+              if matcher.is_a?(Regexp)
+                return entry[:filetype] if matcher.match?(cmd)
+              elsif matcher.to_s == cmd
+                return entry[:filetype]
+              end
+            end
+          end
+          nil
+        end
+
+        # Returns true if the filetype has a color_columns method.
+        def highlight?(ft)
+          entry = @entries[ft]
+          entry && entry[:mod].respond_to?(:color_columns)
+        end
+
+        # Look up entry by filetype. Returns nil if not found.
+        def [](ft)
+          @entries[ft]
+        end
+      end
+    end
+  end
+end

data/lib/ruvim/lang/ruby.rb

@@ -189,6 +189,7 @@ module RuVim
 
       def on_save(ctx, path)
         return unless path && File.exist?(path)
+        return if ctx.editor.respond_to?(:restricted_mode?) && ctx.editor.restricted_mode?
         output, status = Open3.capture2e("ruby", "-wc", path)
         message = output.sub(/^Syntax OK\n?\z/m, "").strip
 
@@ -232,5 +233,11 @@ module RuVim
         cols
       end
     end
+
+    Registry.register("ruby", mod: Ruby,
+      extensions: %w[.rb .rake .ru],
+      basenames: %w[Gemfile Rakefile Guardfile Vagrantfile],
+      shebangs: [/\Aruby(?:\d+(?:\.\d+)*)?\z/],
+      runprg: "ruby -w %")
   end
 end

data/lib/ruvim/lang/rust.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module RuVim
+  module Lang
+    module Rust
+      KEYWORDS = %w[
+        as async await break const continue crate dyn else enum extern
+        false fn for if impl in let loop match mod move mut pub ref
+        return self Self static struct super trait true type unsafe use
+        where while
+        macro_rules
+      ].freeze
+
+      TYPES = %w[
+        bool char str
+        i8 i16 i32 i64 i128 isize
+        u8 u16 u32 u64 u128 usize
+        f32 f64
+        String Vec Box Rc Arc Option Result HashMap HashSet
+        Vec! vec!
+      ].freeze
+
+      ALL_KEYWORDS = (KEYWORDS + TYPES).uniq.freeze
+
+      KEYWORD_RE = /\b(?:#{ALL_KEYWORDS.map { |k| Regexp.escape(k) }.join("|")})\b/
+      STRING_DOUBLE_RE = /"(?:\\.|[^"\\])*"/
+      STRING_RAW_RE = /r#*"[^"]*"#*/
+      CHAR_RE = /'(?:\\.|[^'\\])'/
+      LIFETIME_RE = /'[a-z_]\w*/
+      NUMBER_RE = /\b(?:0[xXoObB][\da-fA-F_]+|\d[\d_]*(?:\.[\d_]+)?(?:[eE][+-]?\d+)?(?:_?[iu](?:8|16|32|64|128|size)|_?f(?:32|64))?)\b/
+      LINE_COMMENT_RE = %r{//.*}
+      BLOCK_COMMENT_RE = %r{/\*.*?\*/}
+      ATTRIBUTE_RE = /#!?\[[\w:(,)\s"]*\]/
+      MACRO_RE = /\b\w+!/
+      CONSTANT_RE = /\b[A-Z][A-Z0-9_]{1,}\b/
+
+      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, 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, LIFETIME_RE, "\e[35m")
+        Highlighter.apply_regex(cols, text, KEYWORD_RE, Highlighter::KEYWORD_COLOR)
+        Highlighter.apply_regex(cols, text, MACRO_RE, "\e[35m")
+        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, ATTRIBUTE_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("rust", mod: Rust,
+      extensions: %w[.rs],
+      runprg: "rustc -o /tmp/a.out % && /tmp/a.out")
+  end
+end

data/lib/ruvim/lang/scheme.rb

@@ -40,5 +40,10 @@ module RuVim
         cols
       end
     end
+
+    Registry.register("scheme", mod: Scheme,
+      extensions: %w[.scm .ss .sld],
+      shebangs: %w[gosh],
+      runprg: "gosh %")
   end
 end