Module: RuVim::Lang::Registry

Defined in:
lib/ruvim/lang/registry.rb

Overview

Central registry for language modules. Each lang module registers itself at load time via Lang.register.

Class Method Summary collapse

Class Method Details

.[](ft) ⇒ Object

Look up entry by filetype. Returns nil if not found.



96
97
98
 
# File 'lib/ruvim/lang/registry.rb', line 96

def [](ft)
  @entries[ft]
end

.detect_by_basename(basename) ⇒ Object

Detect filetype from exact basename. Returns filetype string or nil.



62
63
64
65
66
67
68
69
70
71
72
 
# File 'lib/ruvim/lang/registry.rb', line 62

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_by_extension(ext) ⇒ Object

Detect filetype from file extension. Returns filetype string or nil.



52
53
54
55
56
57
58
 
# File 'lib/ruvim/lang/registry.rb', line 52

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_by_shebang(cmd) ⇒ Object

Detect filetype from shebang command name. Returns filetype string or nil.



76
77
78
79
80
81
82
83
84
85
86
87
 
# File 'lib/ruvim/lang/registry.rb', line 76

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

.highlight?(ft) ⇒ Boolean

Returns true if the filetype has a color_columns method.

Returns:

  • (Boolean) 


90
91
92
93
 
# File 'lib/ruvim/lang/registry.rb', line 90

def highlight?(ft)
  entry = @entries[ft]
  entry && entry[:mod].respond_to?(:color_columns)
end

.register(filetype, mod:, extensions: [], basenames: [], basename_prefix: nil, shebangs: [], aliases: [], runprg: nil) ⇒ Object

Register a language module.

Parameters:

  • filetype (String) —

    primary filetype name (e.g. "ruby")

  • mod (Module) —

    the lang module (must respond to :color_columns)

  • extensions (Array<String>) (defaults to: []) —

    file extensions including dot (e.g. [".rb", ".rake"])

  • basenames (Array<String>) (defaults to: []) —

    exact basenames (e.g. ["Makefile"])

  • basename_prefix (String, nil) (defaults to: nil) —

    prefix match for basename (e.g. "Dockerfile")

  • shebangs (Array<String, Regexp>) (defaults to: []) —

    shebang command matchers

  • aliases (Array<String>) (defaults to: []) —

    additional filetype names that map to the same module

  • runprg (String, nil) (defaults to: nil) —

    default run command (% = filename)



21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
 
# File 'lib/ruvim/lang/registry.rb', line 21

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

.resolve_module(ft) ⇒ Object

Look up a lang module by filetype string. Returns the module or Lang::Base if not found.



39
40
41
42
 
# File 'lib/ruvim/lang/registry.rb', line 39

def resolve_module(ft)
  entry = @entries[ft]
  entry ? entry[:mod] : Lang::Base
end

.runprg_for(ft) ⇒ Object

Look up runprg by filetype string. Returns nil if not registered.



45
46
47
48
 
# File 'lib/ruvim/lang/registry.rb', line 45

def runprg_for(ft)
  entry = @entries[ft]
  entry&.[](:runprg)
end