1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
|
---Helper functions to parse sass color variables
--@module colorizer.sass
local api = vim.api
local uv = vim.loop
local utils = require "colorizer.utils"
local get_last_modified = utils.get_last_modified
local watch_file = utils.watch_file
local DOLLAR_HASH = ("$"):byte()
local AT_HASH = ("@"):byte()
local COLON_HASH = (";"):byte()
local SASS = {}
local function remove_unused_imports(buf, import_name)
if type(SASS[buf].IMPORTS[import_name]) == "table" then
for file, _ in pairs(SASS[buf].IMPORTS[import_name]) do
remove_unused_imports(buf, file)
end
end
SASS[buf].DEFINITIONS[import_name] = nil
SASS[buf].DEFINITIONS_LINEWISE[import_name] = nil
SASS[buf].IMPORTS[import_name] = nil
-- stop the watch handler
pcall(uv.fs_event_stop, SASS[buf].WATCH_IMPORTS[import_name])
SASS[buf].WATCH_IMPORTS[import_name] = nil
end
--- Cleanup sass variables and watch handlers
---@param buf number
local function sass_cleanup(buf)
remove_unused_imports(buf, api.nvim_buf_get_name(buf))
SASS[buf] = nil
end
--- Parse the given line for sass color names
-- check for value in SASS[buf].DEFINITIONS_ALL
---@param line string: Line to parse
---@param i number: Index of line from where to start parsing
---@param buf number
---@return number|nil, string|nil
local function sass_name_parser(line, i, buf)
local variable_name = line:sub(i):match "^%$([%w_-]+)"
if variable_name then
local rgb_hex = SASS[buf].DEFINITIONS_ALL[variable_name]
if rgb_hex then
return #variable_name + 1, rgb_hex
end
end
end
-- Helper function for sass_update_variables
local function sass_parse_lines(buf, line_start, content, name)
SASS[buf].DEFINITIONS_ALL = SASS[buf].DEFINITIONS_ALL or {}
SASS[buf].DEFINITIONS_RECURSIVE_CURRENT = SASS[buf].DEFINITIONS_RECURSIVE_CURRENT or {}
SASS[buf].DEFINITIONS_RECURSIVE_CURRENT_ABSOLUTE = SASS[buf].DEFINITIONS_RECURSIVE_CURRENT_ABSOLUTE or {}
SASS[buf].DEFINITIONS_LINEWISE[name] = SASS[buf].DEFINITIONS_LINEWISE[name] or {}
SASS[buf].DEFINITIONS[name] = SASS[buf].DEFINITIONS[name] or {}
SASS[buf].IMPORTS[name] = SASS[buf].IMPORTS[name] or {}
SASS[buf].WATCH_IMPORTS[name] = SASS[buf].WATCH_IMPORTS[name] or {}
SASS[buf].CURRENT_IMPORTS[name] = {}
local import_find_colon = false
for i, line in ipairs(content) do
local linenum = i - 1 + line_start
-- Invalidate any existing definitions for the lines we are processing.
if not vim.tbl_isempty(SASS[buf].DEFINITIONS_LINEWISE[name][linenum] or {}) then
for v, _ in pairs(SASS[buf].DEFINITIONS_LINEWISE[name][linenum]) do
SASS[buf].DEFINITIONS[name][v] = nil
end
SASS[buf].DEFINITIONS_LINEWISE[name][linenum] = {}
else
SASS[buf].DEFINITIONS_LINEWISE[name][linenum] = {}
end
local index = 1
while index < #line do
-- ignore comments
if line:sub(index, index + 1) == "//" then
index = #line
-- line starting with variables $var
elseif not import_find_colon and line:byte(index) == DOLLAR_HASH then
local variable_name, variable_value = line:match("^%$([%w_-]+)%s*:%s*(.+)%s*", index)
-- Check if we got a variable definition
if variable_name and variable_value then
-- Check for a recursive variable definition.
if variable_value:byte() == DOLLAR_HASH then
local target_variable_name, len = variable_value:match "^%$([%w_-]+)()"
if target_variable_name then
-- Update the value.
SASS[buf].DEFINITIONS_RECURSIVE_CURRENT[variable_name] = target_variable_name
SASS[buf].DEFINITIONS_LINEWISE[name][linenum][variable_name] = true
index = index + len
end
index = index + 1
else
-- Check for a recursive variable definition.
-- If it's not recursive, then just update the value.
if SASS[buf].COLOR_PARSER then
local length, rgb_hex = SASS[buf].COLOR_PARSER(variable_value, 1)
if length and rgb_hex then
SASS[buf].DEFINITIONS[name][variable_name] = rgb_hex
SASS[buf].DEFINITIONS_RECURSIVE_CURRENT[variable_name] = rgb_hex
SASS[buf].DEFINITIONS_RECURSIVE_CURRENT_ABSOLUTE[variable_name] = rgb_hex
SASS[buf].DEFINITIONS_LINEWISE[name][linenum][variable_name] = true
-- added 3 because the color parsers returns 3 less
-- todo: need to fix
index = index + length + 3
end
end
end
index = index + #variable_name
end
-- color ( ; ) found
elseif import_find_colon and line:byte(index) == COLON_HASH then
import_find_colon, index = false, index + 1
-- imports @import 'somefile'
elseif line:byte(index) == AT_HASH or import_find_colon then
local variable_value, colon, import_kw
if import_find_colon then
variable_value, colon = line:match("%s*(.*[^;])%s*([;]?)", index)
else
import_kw, variable_value, colon = line:match("@(%a+)%s+(.+[^;])%s*([;]?)", index)
import_kw = (import_kw == "import" or import_kw == "use")
end
if not colon or colon == "" then
-- now loop until ; is found
import_find_colon = true
else
import_find_colon = false
end
-- if import/use key word is found along with file name
if import_kw and variable_value then
local files = {}
-- grab files to be imported
for s, a in variable_value:gmatch "['\"](.-)()['\"]" do
local folder_path, file_name = vim.fn.fnamemodify(s, ":h"), vim.fn.fnamemodify(s, ":t")
if file_name ~= "" then
-- get the root directory of the file
local parent_dir = vim.fn.fnamemodify(name, ":h")
parent_dir = (parent_dir ~= "") and parent_dir .. "/" or ""
folder_path = vim.fn.fnamemodify(parent_dir .. folder_path, ":p")
file_name = file_name
files = {
folder_path .. file_name .. ".scss",
folder_path .. "_" .. file_name .. ".scss",
folder_path .. file_name .. ".sass",
folder_path .. "_" .. file_name .. ".sass",
}
end
-- why 2 * a ? I don't know
index = index + 2 * a
end
-- process imported files
for _, v in ipairs(files) do
-- parse the sass files
local last_modified = get_last_modified(v)
if last_modified then
-- grab the full path
v = uv.fs_realpath(v)
SASS[buf].CURRENT_IMPORTS[name][v] = true
if not SASS[buf].WATCH_IMPORTS[name][v] then
SASS[buf].IMPORTS[name][v] = last_modified
local c, ind = {}, 0
for l in io.lines(v) do
ind = ind + 1
c[ind] = l
end
sass_parse_lines(buf, 0, c, v)
c = nil
local function watch_callback()
local dimen = vim.api.nvim_buf_call(buf, function()
return { vim.fn.line "w0", vim.fn.line "w$", vim.fn.line "$", vim.api.nvim_win_get_height(0) }
end)
-- todo: Improve this to only refresh highlight for visible lines
-- can't find out how to get visible rows from another window
-- probably a neovim bug, it is returning 1 and 1 or 1 and 5
if
SASS[buf].LOCAL_OPTIONS
and dimen[1] ~= dimen[2]
and ((dimen[3] > dimen[4] and dimen[2] > dimen[4]) or (dimen[2] >= dimen[3]))
then
SASS[buf].LOCAL_OPTIONS.__startline = dimen[1]
SASS[buf].LOCAL_OPTIONS.__endline = dimen[2]
end
SASS[buf].LOCAL_OPTIONS.__event = ""
local lastm = get_last_modified(v)
if lastm then
SASS[buf].IMPORTS[name][v] = lastm
local cc, inde = {}, 0
for l in io.lines(v) do
inde = inde + 1
cc[inde] = l
end
sass_parse_lines(buf, 0, cc, v)
cc = nil
end
require("colorizer.buffer_utils").rehighlight_buffer(
buf,
SASS[buf].OPTIONS,
SASS[buf].LOCAL_OPTIONS,
true
)
end
SASS[buf].WATCH_IMPORTS[name][v] = watch_file(v, watch_callback)
end
else
-- if file does not exists then remove related variables
SASS[buf].IMPORTS[name][v] = nil
pcall(uv.fs_event_stop, SASS[buf].WATCH_IMPORTS[name][v])
SASS[buf].WATCH_IMPORTS[name][v] = nil
end
end -- process imported files
end
end -- parse lines
index = index + 1
end -- while loop end
end -- for loop end
-- remove definitions of files which are not imported now
for file, _ in pairs(SASS[buf].IMPORTS[name]) do
if not SASS[buf].CURRENT_IMPORTS[name][file] then
remove_unused_imports(buf, name)
end
end
end -- sass_parse_lines end
--- Parse the given lines for sass variabled and add to SASS[buf].DEFINITIONS_ALL.
-- which is then used in |sass_name_parser|
-- If lines are not given, then fetch the lines with line_start and line_end
---@param buf number
---@param line_start number
---@param line_end number
---@param lines table|nil
---@param color_parser function|boolean
---@param options table: Buffer options
---@param options_local table|nil: Buffer local variables
local function sass_update_variables(buf, line_start, line_end, lines, color_parser, options, options_local)
lines = lines or vim.api.nvim_buf_get_lines(buf, line_start, line_end, false)
if not SASS[buf] then
SASS[buf] = {
DEFINITIONS_ALL = {},
DEFINITIONS = {},
IMPORTS = {},
WATCH_IMPORTS = {},
CURRENT_IMPORTS = {},
DEFINITIONS_LINEWISE = {},
OPTIONS = options,
LOCAL_OPTIONS = options_local,
}
end
SASS[buf].COLOR_PARSER = color_parser
SASS[buf].DEFINITIONS_ALL = {}
SASS[buf].DEFINITIONS_RECURSIVE_CURRENT = {}
SASS[buf].DEFINITIONS_RECURSIVE_CURRENT_ABSOLUTE = {}
sass_parse_lines(buf, line_start, lines, api.nvim_buf_get_name(buf))
-- add non-recursive def to DEFINITIONS_ALL
for _, color_table in pairs(SASS[buf].DEFINITIONS) do
for color_name, color in pairs(color_table) do
SASS[buf].DEFINITIONS_ALL[color_name] = color
end
end
-- normally this is just a wasted step as all the values here are
-- already present in SASS[buf].DEFINITIONS
-- but when undoing a pasted text, it acts as a backup
for name, color in pairs(SASS[buf].DEFINITIONS_RECURSIVE_CURRENT_ABSOLUTE) do
SASS[buf].DEFINITIONS_ALL[name] = color
end
-- try to find the absolute color value for the given name
-- use tail call recursion
-- https://www.lua.org/pil/6.3.html
local function find_absolute_value(name, color_name)
return SASS[buf].DEFINITIONS_ALL[color_name]
or (
SASS[buf].DEFINITIONS_RECURSIVE_CURRENT[color_name]
and find_absolute_value(name, SASS[buf].DEFINITIONS_RECURSIVE_CURRENT[color_name])
)
end
local function set_color_value(name, color_name)
local value = find_absolute_value(name, color_name)
if value then
SASS[buf].DEFINITIONS_ALL[name] = value
end
SASS[buf].DEFINITIONS_RECURSIVE_CURRENT[name] = nil
end
for name, color_name in pairs(SASS[buf].DEFINITIONS_RECURSIVE_CURRENT) do
set_color_value(name, color_name)
end
SASS[buf].DEFINITIONS_RECURSIVE_CURRENT = nil
SASS[buf].DEFINITIONS_RECURSIVE_CURRENT_ABSOLUTE = nil
end
--- @export
return {
sass_cleanup = sass_cleanup,
sass_name_parser = sass_name_parser,
sass_update_variables = sass_update_variables,
}
|