lualine.nvim/lua/lualine/utils/loader.lua

-- Copyright (c) 2020-2021 hoob3rt
-- MIT license, see LICENSE for more details.

local lualine_require = require 'lualine_require'
local require = lualine_require.require
local modules = lualine_require.lazy_require {
  notice = 'lualine.utils.notices',
}
local is_valid_filename = lualine_require.is_valid_filename

local sep = lualine_require.sep

local component_types = {
  luaf = function(component)
    return require('lualine.components.special.function_component'):new(component)
  end,
  mod = function(component)
    local ok, loaded_component = pcall(require, 'lualine.components.' .. component[1])
    if ok then
      component.component_name = component[1]
      loaded_component = loaded_component:new(component)
      return loaded_component
    end
  end,
  stl = function(component)
    local stl_expr = component[1] -- Vim's %p %l statusline elements
    component[1] = function()
      return stl_expr
    end
    return require('lualine.components.special.function_component'):new(component)
  end,
  var = function(component)
    return require('lualine.components.special.vim_var_component'):new(component)
  end,
  ['_'] = function(component)
    return require('lualine.components.special.eval_func_component'):new(component)
  end,
}

local function component_loader(component)
  if type(component[1]) == 'function' then
    return component_types.luaf(component)
  end
  if type(component[1]) == 'string' then
    -- load the component
    if component.type ~= nil then
      if component_types[component.type] and component.type ~= 'luaf' then
        return component_types[component.type](component)
      elseif component.type == 'vimf' or component.type == 'luae' then
        return component_types['_'](component)
      else
        modules.notice.add_notice(string.format(
          [[
### component.type

component type '%s' isn't recognised. Check if spelling is correct.]],
          component.type
        ))
      end
    end
    local loaded_component = component_types.mod(component)
    if loaded_component then
      return loaded_component
    elseif string.char(component[1]:byte(1)) == '%' then
      return component_types.stl(component)
    elseif component[1]:find '[gvtwb]?o?:' == 1 then
      return component_types.var(component)
    else
      return component_types['_'](component)
    end
  end
end

local function option_deprecatation_notice(component)
  local types = {
    case = function()
      local kind = component.upper ~= nil and 'upper' or 'lower'
      modules.notice.add_notice(string.format(
        [[
### option.%s

Option `%s` has been deprecated.
Please use `fmt` option if you need to change case of a component.

You have some thing like this in your config:

```lua
  %s = true,
```

You'll have to change it to this to retain old behavior:

```lua
  fmt = string.%s
```
]],
        kind,
        kind,
        kind,
        kind
      ))
    end,
    padding = function()
      local kind = component.left_padding ~= nil and 'left_padding' or 'right_padding'
      modules.notice.add_notice(string.format(
        [[
### option.%s

Option `%s` has been deprecated.
Please use `padding` option to set left/right padding.

You have some thing like this in your config:

```lua
  %s = %d,
```

You'll have to change it to this to retain old behavior:

```lua
  padding = { %s = %d }
```
if you've set both left_padding and right_padding for a component
you'll need to have something like
```lua
  padding = { left = x, right = y }
```
When you set `padding = x` it's same as `padding = {left = x, right = x}`
]],
        kind,
        kind,
        kind,
        component[kind],
        kind == 'left_padding' and 'left' or 'right',
        component[kind]
      ))
      if component.left_padding and component.right_padding then
        component.padding = { left = component.left_padding, right = component.right_padding }
        component.left_padding = nil
        component.right_padding = nil
      elseif component.left_padding then
        component.padding = { left = component.left_padding, right = 1 }
        component.left_padding = nil
      else
        component.padding = { left = 1, right = component.right_padding }
        component.right_padding = nil
      end
    end,
  }
  if component.upper ~= nil or component.lower ~= nil then
    types.case()
  end
  if component.left_padding ~= nil or component.right_padding ~= nil then
    types.padding()
  end
end

local function load_sections(sections, options)
  for section_name, section in pairs(sections) do
    for index, component in pairs(section) do
      if type(component) == 'string' or type(component) == 'function' then
        component = { component }
      end
      component.self = {}
      component.self.section = section_name
      -- apply default args
      component = vim.tbl_extend('keep', component, options)
      option_deprecatation_notice(component)
      section[index] = component_loader(component)
    end
  end
end

local function load_components(config)
  load_sections(config.sections, config.options)
  load_sections(config.inactive_sections, config.options)
  load_sections(config.tabline, config.options)
end

local function load_extensions(config)
  local loaded_extensions = {}
  for _, extension in pairs(config.extensions) do
    if type(extension) == 'string' then
      local ok, local_extension = pcall(require, 'lualine.extensions.' .. extension)
      if ok then
        local_extension = vim.deepcopy(local_extension)
        load_sections(local_extension.sections, config.options)
        if local_extension.inactive_sections then
          load_sections(local_extension.inactive_sections, config.options)
        end
        if type(local_extension.init) == 'function' then
          local_extension.init()
        end
        table.insert(loaded_extensions, local_extension)
      else
        modules.notice.add_notice(string.format(
          [[
### Extensions
Extension named `%s` was not found . Check if spelling is correct.
]],
          extension
        ))
      end
    elseif type(extension) == 'table' then
      local local_extension = vim.deepcopy(extension)
      load_sections(local_extension.sections, config.options)
      if local_extension.inactive_sections then
        load_sections(local_extension.inactive_sections, config.options)
      end
      if type(local_extension.init) == 'function' then
        local_extension.init()
      end
      table.insert(loaded_extensions, local_extension)
    end
  end
  config.extensions = loaded_extensions
end

local function load_all(config)
  load_components(config)
  load_extensions(config)
end

local function load_theme(theme_name)
  assert(is_valid_filename(theme_name), 'Invalid filename')
  local retval
  local path = table.concat { 'lua/lualine/themes/', theme_name, '.lua' }
  local files = vim.api.nvim_get_runtime_file(path, true)
  local n_files = #files
  if n_files == 0 then
    -- No match found
    error(path .. ' Not found')
  elseif n_files == 1 then
    -- when only one is found run that and return it's return value
    retval = dofile(files[1])
  else
    -- More then 1 found . Use the first one that isn't in lualines repo
    local lualine_repo_pattern = table.concat({ 'lualine.nvim', 'lua', 'lualine' }, sep)
    local file_found = false
    for _, file in ipairs(files) do
      if not file:find(lualine_repo_pattern) then
        retval = dofile(file)
        file_found = true
        break
      end
    end
    if not file_found then
      -- This shouldn't happen but somehow we have multiple files but they
      -- apear to be in lualines repo . Just run the first one
      retval = dofile(files[1])
    end
  end
  return retval
end

return {
  load_all = load_all,
  load_theme = load_theme,
}