vis-config

modelines.lua

(5196B)

 --
 -- vis-modelines
 --
 -- Vim's modelines are very useful for setting per-file settings in Vim.
 -- For example, the filetype can't always be reliably inferred from the
 -- filename, i.e. for templates with generic file extensions or script files
 -- that omit the file extension altogether.
 --
 -- This Vis plugin tries to read standard Vim modelines and set the following
 -- (Vis) settings:
 --
 -- autoindent, expandtab, numbers, tabwidth, syntax.
 --
 -- Vim (by default) looks for modelines in the first 5 and last 5 lines of the
 -- file. This will emulate this behaviour, but omit the setting to change this
 -- threshold, as no sane person would change it (it would break everybody
 -- else's Vim).
 --
 -- This parser assumes you will only use *one* modeline per file, to avoid
 -- having to resolve conflicts. It will use the first modeline it finds from
 -- the top.
 --
 
 local lpeg = require("lpeg")
 local P, C, Ct, R, S = lpeg.P, lpeg.C, lpeg.Ct, lpeg.R, lpeg.S
 
 -- vim has two styles for modelines:
 --
 -- 'set' style, can be delimeted with a : at the end. Delimiter is whitespace.
 -- E.g.: vim: set ft=lua sw=2 ts=2 autoindent:
 --
 -- Colon style, modeline continues to the end of the line. Delimeter is
 -- whitespace or ':'.
 -- E.g.: vim: noai:ts=4:sw=4 ft=lua
 --
 -- (All parsing based on the information in :help modeline)
 
 local digit         = R("09")
 local num           = digit * digit * digit
 local ver           = S("><=") * num + num + P("")
 local vim           = P(" vim")*ver*":" + " Vim"*ver*":" + " vi:" + " ex:"
 
 local whitespace    = S("\t ")^1
 local optwhitespace = whitespace + P("")
 local prefix        = (1-vim)^0 * vim * optwhitespace
 
 local optchars      = R("az", "AZ") + R("09") + S("_\"\'")
 local option        = Ct(C(optchars^1) * "=" * C(optchars^1)) + C(optchars^1)
 
 local set           = P("set") + P("se")
 local setstyle      = set * (whitespace * option)^0 * P(":")^-1
 local separator     = (optwhitespace * P(":") * optwhitespace) + whitespace
 local colonstyle    = option * (separator * option)^0
 
 -- matches & captures options
 local modeline = Ct(prefix * (setstyle + colonstyle))
 
 -- detects modelines
 local modeline_detect = prefix * optwhitespace
 
 -- Simple Vim settings like 'autoindent' without options are mapped directly to
 -- a command for Vis. If the settings is a variable (like 'ft=lua'), a mapping
 -- function is used to generate the Vis command.
 
 local sw_set = false
 
 local function sw_f(value)
     sw_set = true
     return "set tw "..value
 end
 
 local function ts_f(value)
     if not sw_set then
         return "set tw "..value
     else
         return nil
     end
 end
 
 local command_mapping = {
     autoindent      = "set ai on",
     noautoindent    = "set ai off",
     ai              = "set ai on",
     noai            = "set ai off",
     expandtab       = "set et on",
     noexpandtab     = "set et off",
     et              = "set et on",
     noet            = "set et off",
     number          = "set nu on",
     nonumber        = "set nu off",
     nu              = "set nu on",
     nonu            = "set nu off",
     ft              = function(value) return "set syntax "..value end,
     filetype        = function(value) return "set syntax "..value end,
 
     -- Vis only knows the 'tabwidth' setting instead of 'sw' and 'ts' settings.
     -- We prefer the 'sw' setting for 'tabwidth', because it is what the
     -- modeline wants to be inserted. How it is displayed is somewhat less
     -- important.
     sw              = sw_f,
     shiftwidth      = sw_f,
     ts              = ts_f,
     tabstop         = ts_f
 }
 
 local function parse_modeline(line)
     return modeline:match(line)
 end
 
 local function map_options(line)
     local commands = {}
     local opts = parse_modeline(line)
     if not opts then return nil end
 
     for _,o in pairs(opts) do
         if type(o) == "string" then     -- simple options are stored as strings
             local c = command_mapping[o]
             if c then
                 table.insert(commands, c)
             end
         elseif type(o) == "table" then  -- variables are stored as a table
             local map_f = command_mapping[o[1]]
             if map_f then
                 local c = map_f(o[2])
                 if c then table.insert(commands, c) end
             end
         end
     end
     return commands
 end
 
 local function find_modeline(lines)
     if not lines then return nil end
     if #lines < 10 then
         for i=1,#lines do
             local l = lines[i]
             if modeline_detect:match(l) then
                 return l
             end
         end
     else
         for i=1,5 do
             local l = lines[i]
             if modeline_detect:match(l) then
                 return l
             end
         end
         for i=0,4 do
             local l = lines[#lines - i]
             if modeline_detect:match(l) then
                 return l
             end
         end
     end
     return nil
 end
 
 vis.events.subscribe(vis.events.START, function()
     local file = vis.win.file
     if not file then return end
     local ml = find_modeline(file.lines)
     if not ml then return end
     local commands = map_options(ml)
     for _,c in pairs(commands) do
         vis:command(c)
     end
 end)