lualine.nvim/lua/lualine/components/fileformat.lua

-- Copyright (c) 2020-2021 shadmansaleh
-- MIT license, see LICENSE for more details.
local M = require('lualine.component'):extend()

-- stylua: ignore
M.icon = {
  unix = '', -- e712
  dos  = '', -- e70f
  mac  = ''  -- e711
}

M.update_status = function(self)
  if self.options.icons_enabled and not self.options.icon then
    local format = vim.bo.fileformat
    return M.icon[format] or format
  end
  return vim.bo.fileformat
end

return M
feat: adding component specific options (#60) 2021-02-16 00:09:12 +06:00			`-- Copyright (c) 2020-2021 shadmansaleh`
docs: added license to all source files 2021-02-13 01:03:57 +01:00			`-- MIT license, see LICENSE for more details.`
refactor: separate the child creation and initialization (#81) - includes modified class implementation from https://github.com/rxi/classic/blob/master/classic.lua - now base component class is created from classic. - change to how component classes are created. - Don't overwrite new method to initialize a component. Overwrite the init method. new is responsible for creating class object and calling init on it. Unlike previous new overwrite you don't need to create the class (table) and return it. Instead you will recive the object as self and do required manipulation on that just like any most other oop langs. Also don't need to return anything from init. init's job is to initialize. remember to call classes init before running your operations unfortunately lua isn't full fledged oop lang and I don't how to automate this. - changes how super classes are accesed. - rename Component._parent -> Component.super - methods on super classes now ran through super class instead of objects _parent self._parent as that can lead to recursive inf loop. See branch, diff, tabs, buffer classes call to init for example on pattern. - All components updated to reflect current logic - component loader updated to use new initialization procedure. - updated tests - updated BREAKING_CHANGES.md - plus quite a bit of formatting changes in the components - comp.method = function(self, ...) -> function M:method(...) BREAKING_CHANGE 2021-09-25 23:15:42 +06:00			`local M = require('lualine.component'):extend()`
Refactor: Components now use OOP style (#141) 2021-04-11 14:20:41 +06:00
chore: use stylua for formating * Switch to stylua for formating * Change lua-format ignore to stylua ignore. * Add workflow for formating with stylua 2021-09-04 00:20:34 +06:00			`-- stylua: ignore`
refactor: separate the child creation and initialization (#81) - includes modified class implementation from https://github.com/rxi/classic/blob/master/classic.lua - now base component class is created from classic. - change to how component classes are created. - Don't overwrite new method to initialize a component. Overwrite the init method. new is responsible for creating class object and calling init on it. Unlike previous new overwrite you don't need to create the class (table) and return it. Instead you will recive the object as self and do required manipulation on that just like any most other oop langs. Also don't need to return anything from init. init's job is to initialize. remember to call classes init before running your operations unfortunately lua isn't full fledged oop lang and I don't how to automate this. - changes how super classes are accesed. - rename Component._parent -> Component.super - methods on super classes now ran through super class instead of objects _parent self._parent as that can lead to recursive inf loop. See branch, diff, tabs, buffer classes call to init for example on pattern. - All components updated to reflect current logic - component loader updated to use new initialization procedure. - updated tests - updated BREAKING_CHANGES.md - plus quite a bit of formatting changes in the components - comp.method = function(self, ...) -> function M:method(...) BREAKING_CHANGE 2021-09-25 23:15:42 +06:00			`M.icon = {`
Refactor: Components now use OOP style (#141) 2021-04-11 14:20:41 +06:00			`unix = '', -- e712`
chore: use stylua for formating * Switch to stylua for formating * Change lua-format ignore to stylua ignore. * Add workflow for formating with stylua 2021-09-04 00:20:34 +06:00			`dos = '', -- e70f`
			`mac = '' -- e711`
Refactor: Components now use OOP style (#141) 2021-04-11 14:20:41 +06:00			`}`

refactor: separate the child creation and initialization (#81) - includes modified class implementation from https://github.com/rxi/classic/blob/master/classic.lua - now base component class is created from classic. - change to how component classes are created. - Don't overwrite new method to initialize a component. Overwrite the init method. new is responsible for creating class object and calling init on it. Unlike previous new overwrite you don't need to create the class (table) and return it. Instead you will recive the object as self and do required manipulation on that just like any most other oop langs. Also don't need to return anything from init. init's job is to initialize. remember to call classes init before running your operations unfortunately lua isn't full fledged oop lang and I don't how to automate this. - changes how super classes are accesed. - rename Component._parent -> Component.super - methods on super classes now ran through super class instead of objects _parent self._parent as that can lead to recursive inf loop. See branch, diff, tabs, buffer classes call to init for example on pattern. - All components updated to reflect current logic - component loader updated to use new initialization procedure. - updated tests - updated BREAKING_CHANGES.md - plus quite a bit of formatting changes in the components - comp.method = function(self, ...) -> function M:method(...) BREAKING_CHANGE 2021-09-25 23:15:42 +06:00			`M.update_status = function(self)`
Refactor: Components now use OOP style (#141) 2021-04-11 14:20:41 +06:00			`if self.options.icons_enabled and not self.options.icon then`
			`local format = vim.bo.fileformat`
refactor: separate the child creation and initialization (#81) - includes modified class implementation from https://github.com/rxi/classic/blob/master/classic.lua - now base component class is created from classic. - change to how component classes are created. - Don't overwrite new method to initialize a component. Overwrite the init method. new is responsible for creating class object and calling init on it. Unlike previous new overwrite you don't need to create the class (table) and return it. Instead you will recive the object as self and do required manipulation on that just like any most other oop langs. Also don't need to return anything from init. init's job is to initialize. remember to call classes init before running your operations unfortunately lua isn't full fledged oop lang and I don't how to automate this. - changes how super classes are accesed. - rename Component._parent -> Component.super - methods on super classes now ran through super class instead of objects _parent self._parent as that can lead to recursive inf loop. See branch, diff, tabs, buffer classes call to init for example on pattern. - All components updated to reflect current logic - component loader updated to use new initialization procedure. - updated tests - updated BREAKING_CHANGES.md - plus quite a bit of formatting changes in the components - comp.method = function(self, ...) -> function M:method(...) BREAKING_CHANGE 2021-09-25 23:15:42 +06:00			`return M.icon[format] or format`
feat: adding component specific options (#60) 2021-02-16 00:09:12 +06:00			`end`
Refactor: Components now use OOP style (#141) 2021-04-11 14:20:41 +06:00			`return vim.bo.fileformat`
initial lualine setup 2020-12-30 15:48:51 +01:00			`end`

refactor: separate the child creation and initialization (#81) - includes modified class implementation from https://github.com/rxi/classic/blob/master/classic.lua - now base component class is created from classic. - change to how component classes are created. - Don't overwrite new method to initialize a component. Overwrite the init method. new is responsible for creating class object and calling init on it. Unlike previous new overwrite you don't need to create the class (table) and return it. Instead you will recive the object as self and do required manipulation on that just like any most other oop langs. Also don't need to return anything from init. init's job is to initialize. remember to call classes init before running your operations unfortunately lua isn't full fledged oop lang and I don't how to automate this. - changes how super classes are accesed. - rename Component._parent -> Component.super - methods on super classes now ran through super class instead of objects _parent self._parent as that can lead to recursive inf loop. See branch, diff, tabs, buffer classes call to init for example on pattern. - All components updated to reflect current logic - component loader updated to use new initialization procedure. - updated tests - updated BREAKING_CHANGES.md - plus quite a bit of formatting changes in the components - comp.method = function(self, ...) -> function M:method(...) BREAKING_CHANGE 2021-09-25 23:15:42 +06:00			`return M`