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
|
local Optional = require "mason-core.optional"
local Result = require "mason-core.result"
local _ = require "mason-core.functional"
local a = require "mason-core.async"
local async_control = require "mason-core.async.control"
local async_uv = require "mason-core.async.uv"
local fs = require "mason-core.fs"
local log = require "mason-core.log"
local path = require "mason-core.path"
local spawn = require "mason-core.spawn"
local util = require "mason-registry.sources.util"
local Channel = async_control.Channel
---@class FileRegistrySourceSpec
---@field path string
---@class FileRegistrySource : RegistrySource
---@field spec FileRegistrySourceSpec
---@field root_dir string
---@field buffer { specs: RegistryPackageSpec[], instances: table<string, Package> }?
local FileRegistrySource = {}
FileRegistrySource.__index = FileRegistrySource
---@param spec FileRegistrySourceSpec
function FileRegistrySource:new(spec)
---@type FileRegistrySource
local instance = {}
setmetatable(instance, self)
instance.spec = spec
return instance
end
function FileRegistrySource:is_installed()
return self.buffer ~= nil
end
---@return RegistryPackageSpec[]
function FileRegistrySource:get_all_package_specs()
return _.filter_map(util.map_registry_spec, self:get_buffer().specs)
end
---@param specs RegistryPackageSpec[]
function FileRegistrySource:reload(specs)
self.buffer = _.assoc("specs", specs, self.buffer or {})
self.buffer.instances = _.compose(
_.index_by(_.prop "name"),
_.map(util.hydrate_package(self.buffer.instances or {}))
)(self:get_all_package_specs())
return self.buffer
end
function FileRegistrySource:get_buffer()
return self.buffer or {
specs = {},
instances = {},
}
end
---@param pkg_name string
---@return Package?
function FileRegistrySource:get_package(pkg_name)
return self:get_buffer().instances[pkg_name]
end
function FileRegistrySource:get_all_package_names()
return _.map(_.prop "name", self:get_all_package_specs())
end
function FileRegistrySource:get_installer()
return Optional.of(_.partial(self.install, self))
end
---@async
function FileRegistrySource:install()
return Result.try(function(try)
a.scheduler()
if vim.fn.executable "yq" ~= 1 then
return Result.failure "yq is not installed."
end
local yq = vim.fn.exepath "yq"
local registry_dir = vim.fn.expand(self.spec.path) --[[@as string]]
local packages_dir = path.concat { registry_dir, "packages" }
if not fs.async.dir_exists(registry_dir) then
return Result.failure(("Directory %s does not exist."):format(registry_dir))
end
if not fs.async.dir_exists(packages_dir) then
return Result.failure "packages/ directory is missing."
end
---@type ReaddirEntry[]
local entries = _.filter(_.prop_eq("type", "directory"), fs.async.readdir(packages_dir))
local streaming_parser = coroutine.wrap(function()
local buffer = ""
while true do
local delim = buffer:find("\n", 1, true)
if delim then
local content = buffer:sub(1, delim - 1)
buffer = buffer:sub(delim + 1)
local chunk = coroutine.yield(content)
buffer = buffer .. chunk
else
local chunk = coroutine.yield()
buffer = buffer .. chunk
end
end
end)
-- Initialize parser coroutine.
streaming_parser()
local specs = {}
local stderr_buffer = {}
local parse_failures = 0
---@param raw_spec string
local function handle_spec(raw_spec)
local ok, result = pcall(vim.json.decode, raw_spec)
if ok then
specs[#specs + 1] = result
else
log.fmt_error("Failed to parse JSON, err=%s, json=%s", result, raw_spec)
parse_failures = parse_failures + 1
end
end
try(spawn
[yq]({
"-I0", -- output one document per line
{ "-o", "json" },
stdio_sink = {
stdout = function(chunk)
local raw_spec = streaming_parser(chunk)
if raw_spec then
handle_spec(raw_spec)
end
end,
stderr = function(chunk)
stderr_buffer[#stderr_buffer + 1] = chunk
end,
},
on_spawn = a.scope(function(_, stdio)
local stdin = stdio[1]
for _, entry in ipairs(entries) do
local contents = fs.async.read_file(path.concat { packages_dir, entry.name, "package.yaml" })
async_uv.write(stdin, contents)
end
async_uv.shutdown(stdin)
async_uv.close(stdin)
end),
})
:map_err(function()
return ("Failed to parse package YAML: %s"):format(table.concat(stderr_buffer, ""))
end))
-- Exhaust parser coroutine.
for raw_spec in
function()
return streaming_parser ""
end
do
handle_spec(raw_spec)
end
if parse_failures > 0 then
return Result.failure(("Failed to parse %d packages."):format(parse_failures))
end
return specs
end)
:on_success(function(specs)
self:reload(specs)
end)
:on_failure(function(err)
log.fmt_error("Failed to install registry %s. %s", self, err)
end)
end
function FileRegistrySource:get_display_name()
if self:is_installed() then
return ("local: %s"):format(self.spec.path)
else
return ("local: %s [uninstalled]"):format(self.spec.path)
end
end
function FileRegistrySource:__tostring()
return ("FileRegistrySource(path=%s)"):format(self.spec.path)
end
return FileRegistrySource
|
