11482869644

Committed 23 Oct 2024 03:11PM UTC coverage: 82.843% (+0.2%) from 82.674%

Build # 11482869644

Build Type

push

github

Committed by

mxcl

Commit Message

Use deno^2 (#79)

Run Details

553 of 734 branches covered (75.34%)

Branch coverage included in aggregate %.

71 of 84 new or added lines in 9 files covered. (84.52%)

3 existing lines in 3 files now uncovered.

2460 of 2903 relevant lines covered (84.74%)

2673.48 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

69.34

/src/hooks/usePantry.ts

import { is_what, PlainObject } from "../deps.ts"
const { isNumber, isPlainObject, isString, isArray, isPrimitive, isBoolean } = is_what
import { Package, Installation, PackageRequirement } from "../types.ts"
import { provides as cache_provides, available as cache_available, runtime_env as cache_runtime_env, companions as cache_companions, dependencies as cache_dependencies } from "./useSyncCache.ts";
import SemVer, * as semver from "../utils/semver.ts"
import useMoustaches from "./useMoustaches.ts"
import { PkgxError } from "../utils/error.ts"
import { validate } from "../utils/misc.ts"
import * as pkgutils from "../utils/pkg.ts"
import useConfig from "./useConfig.ts"
import host from "../utils/host.ts"
import Path from "../utils/Path.ts"

export interface Interpreter {
  project: string // FIXME: should probably be a stronger type
  args: string[]
}

export class PantryError extends PkgxError
{}

export class PantryParseError extends PantryError {
  project: string
  path?: Path

  constructor(project: string, path?: Path, cause?: unknown) {
    super(`package.yml parse error: ${path ?? project}`)
    this.project = project
    this.path = path
    this.cause = cause
  }
}

export class PackageNotFoundError extends PantryError {
  project: string
  constructor(project: string) {
    super(`pkg not found: ${project}`)
    this.project = project
  }
}

export class PantryNotFoundError extends PantryError {
  constructor(path: Path) {
    super(`pantry not found: ${path}`)
  }
}

export default function usePantry() {
  const prefix = useConfig().data.join("pantry/projects")
  const is_cache_available = cache_available() && pantry_paths().length == 1

  async function* ls(): AsyncGenerator<LsEntry> {
    const seen = new Set()

    for (const prefix of pantry_paths()) {
      for await (const path of _ls_pantry(prefix)) {
        const project = path.parent().relative({ to: prefix })
        if (seen.insert(project).inserted) {
          yield { project, path }
        }
      }
    }
  }

  const project = (input: string | { project: string }) => {
    const project = isString(input) ? input : input.project

    const yaml = (() => {
      for (const prefix of pantry_paths()) {
        if (!prefix.exists()) throw new PantryNotFoundError(prefix.parent())
        const dir = prefix.join(project)
        const filename = dir.join("package.yml")
        if (!filename.exists()) continue

        let memo: Promise<PlainObject> | undefined

        return () => memo ?? (memo = filename.readYAML()
          .then(validate.obj)
          .catch(cause => { throw new PantryParseError(project, filename, cause) }))
      }
      throw new PackageNotFoundError(project)
    })()

    const companions = async () => {
      if (is_cache_available) {
        return await cache_companions(project) ?? parse_pkgs_node((await yaml())["companions"])
      } else {
        return parse_pkgs_node((await yaml())["companions"])
      }
    }

    const runtime_env = async (version: SemVer, deps: Installation[]) => {
      const obj = await (async () => {
        if (is_cache_available) {
          const cached = await cache_runtime_env(project)
          if (cached) return cached
        }
        const yml = await yaml()
        return validate.obj(yml["runtime"]?.["env"] ?? {})
      })()
      return expand_env_obj(obj, { project, version }, deps)
    }

    const available = async (): Promise<boolean> => {
      let { platforms } = await yaml()
      if (!platforms) return true
      if (isString(platforms)) platforms = [platforms]
      if (!isArray(platforms)) throw new PantryParseError(project)
      return platforms.includes(host().platform) ||platforms.includes(`${host().platform}/${host().arch}`)
    }

    const drydeps = async () => {
      if (is_cache_available) {
        return await cache_dependencies(project) ?? parse_pkgs_node((await yaml()).dependencies)
      } else {
        return parse_pkgs_node((await yaml()).dependencies)
      }
    }

    const provides = async () => {
      let node = (await yaml())["provides"]
      if (!node) return []
      if (isPlainObject(node)) {
        node = node[host().platform]
      }
      if (!isArray(node)) throw new PantryParseError(project)

      return node.compact(x => {
        if (isPlainObject(x)) {
          x = x["executable"]
        }
        if (isString(x)) {
          if (x.startsWith("bin/")) return x.slice(4)
          if (x.startsWith("sbin/")) return x.slice(5)
        }
      })
    }

    const provider = async () => {
      for (const prefix of pantry_paths()) {
        if (!prefix.exists()) continue
        const dir = prefix.join(project)
        const filename = dir.join("provider.yml")
        if (!filename.exists()) continue
        const yaml = validate.obj(await filename.readYAML())
        const cmds = validate.arr<string>(yaml.cmds)
        return (binname: string) => {
          if (!cmds.includes(binname)) return
          const args = yaml['args']
          if (isPlainObject(args)) {
            if (args[binname]) {
              return get_args(args[binname])
            } else {
              return get_args(args['...'])
            }
          } else {
            return get_args(args)
          }
        }
      }
      function get_args(input: unknown) {
        if (isString(input)) {
          return input.split(/\s+/)
        } else {
          return validate.arr<string>(input)
        }
      }
    }

    return {
      companions,
      runtime: {
        env: runtime_env,
        deps: drydeps
      },
      available,
      provides,
      provider,
      yaml
    }
  }

  /// finds a project that matches the input string on either name, display-name or FQD project name
  /// - Returns: Project[] since there may by multiple matches, if you want a single match you should use `project()`
  async function find(name: string) {
    type Foo = ReturnType<typeof project> & LsEntry

    //lol FIXME
    name = pkgutils.parse(name).project

    if (prefix.join(name).isDirectory()) {
      const foo = project(name)
      return [{...foo, project: name }]
    }

    /// only use cache if PKGX_PANTRY_PATH is not set
    if (is_cache_available) {
      const cached = await cache_provides(name)
      if (cached?.length) {
        return cached.map(x => ({
          ...project(x),
          project: x
        }))
      }

      // else we need to still check for display-names
    }

    name = name.toLowerCase()

    //TODO not very performant due to serial awaits
    const rv: Foo[] = []
    for await (const pkg of ls()) {
      const proj = {...project(pkg.project), ...pkg}
      if (pkg.project.toLowerCase() == name) {
        rv.push(proj)
        continue
      }
      const yaml = await proj.yaml().swallow()
      if (!yaml) {
        console.warn("warn: parse failure:", pkg.project)
      } else if (yaml["display-name"]?.toLowerCase() == name) {
        rv.push(proj)
      } else if ((await proj.provides()).map(x => x.toLowerCase()).includes(name)) {
        rv.push(proj)
      }
    }
    return rv
  }

  async function which({ interprets: extension }: { interprets: string }): Promise<Interpreter | undefined> {
    if (extension[0] == '.') extension = extension.slice(1)
    if (!extension) return
    for await (const pkg of ls()) {
      const yml = await project(pkg).yaml()
      const node = yml["interprets"]
      if (!isPlainObject(node)) continue
      try {
        const { extensions, args } = yml["interprets"]
        if ((isString(extensions) && extensions === extension) ||
          (isArray(extensions) && extensions.includes(extension))) {
          return { project: pkg.project, args: isArray(args) ? args : [args] }
        }
      } catch {
        continue
      }
    }
    return undefined
  }

  const missing = () => {
    try {
      return !pantry_paths().some(x => x.exists())
    } catch (e) {
      if (e instanceof PantryNotFoundError) {
        return true
      } else {
        throw e
      }
    }
  }

  return {
    prefix,
    which,
    ls,
    project,
    find,
    parse_pkgs_node,
    expand_env_obj,
    missing,
    pantry_paths
  }

  function pantry_paths(): Path[] {
    const rv: Path[] = []

    if (prefix.isDirectory()) {
      rv.push(prefix)
    }
    for (const path of useConfig().pantries.reverse()) {
      rv.unshift(path.join("projects"))
    }

    if (rv.length == 0) {
      throw new PantryNotFoundError(prefix)
    }

    return rv
  }
}

// deno-lint-ignore no-explicit-any
export function parse_pkgs_node(node: any) {
  if (!node) return []
  node = validate.obj(node)
  platform_reduce(node)

  return Object.entries(node)
    .compact(([project, constraint]) =>
      validatePackageRequirement(project, constraint))
}

export function validatePackageRequirement(project: string, constraint: unknown): PackageRequirement {
  if (isNumber(constraint)) {
    constraint = `^${constraint}`
  } else if (!isString(constraint)) {
    throw new Error(`invalid constraint for ${project}: ${constraint}`)
  }

  constraint = semver.Range.parse(constraint as string)
  if (!constraint) {
    throw new PkgxError("invalid constraint for " + project + ": " + constraint)
  }

  return {
    project,
    constraint: constraint as semver.Range
  }
}

/// expands platform specific keys into the object
/// expands inplace because JS is nuts and you have to suck it up
function platform_reduce(env: PlainObject) {
  const sys = host()
  for (const [key, value] of Object.entries(env)) {
    const [os, arch] = (() => {
      let match = key.match(/^(darwin|linux)\/(aarch64|x86-64)$/)
      if (match) return [match[1], match[2]]
      if ((match = key.match(/^(darwin|linux)$/))) return [match[1]]
      if ((match = key.match(/^(aarch64|x86-64)$/))) return [,match[1]]
      return []
    })()

    if (!os && !arch) continue
    delete env[key]
    if (os && os != sys.platform) continue
    if (arch && arch != sys.arch) continue

    const dict = validate.obj(value)
    for (const [key, value] of Object.entries(dict)) {
      // if user specifies an array then we assume we are supplementing
      // otherwise we are replacing. If this is too magical let us know
      if (isArray(value)) {
        if (!env[key]) env[key] = []
        else if (!isArray(env[key])) env[key] = [env[key]]
        //TODO if all-platforms version comes after the specific then order accordingly
        env[key].push(...value)
      } else {
        env[key] = value
      }
    }
  }
}

export function expand_env_obj(env_: PlainObject, pkg: Package, deps: Installation[]): Record<string, string> {
  const env = {...env_}

  platform_reduce(env)

  const rv: Record<string, string> = {}

  for (let [key, value] of Object.entries(env)) {
    if (isArray(value)) {
      value = value.map(x => transform(x)).join(" ")
    } else {
      value = transform(value)
    }

    if (Deno.build.os == 'windows') {
      // we standardize on UNIX directory separators
      // NOTE hopefully this won’t break anything :/
      value = value.replaceAll('/', '\\')
    }

    rv[key] = value
  }

  return rv

  // deno-lint-ignore no-explicit-any
  function transform(value: any): string {
    if (!isPrimitive(value)) throw new PantryParseError(pkg.project, undefined, JSON.stringify(value))

    if (isBoolean(value)) {
      return value ? "1" : "0"
    } else if (value === undefined || value === null) {
      return "0"
    } else if (isString(value)) {
      const mm = useMoustaches()
      const home = Path.home().string
      const obj = [
        { from: 'home', to: home }       // remove, stick with just ~
      ]
      obj.push(...mm.tokenize.all(pkg, deps))
      return mm.apply(value, obj)
    } else if (isNumber(value)) {
      return value.toString()
    }

    const e = new Error("unexpected error")
    e.cause = value
    throw e
  }
}

interface LsEntry {
  project: string
  path: Path
}

async function* _ls_pantry(dir: Path): AsyncGenerator<Path> {
  if (!dir.isDirectory()) throw new PantryNotFoundError(dir)

  for await (const [path, { name, isDirectory }] of dir.ls()) {
    if (isDirectory) {
      for await (const x of _ls_pantry(path)) {
        yield x
      }
    } else if (name === "package.yml" || name === "package.yaml") {
      yield path
    }
  }
}

1	import { is_what, PlainObject } from "../deps.ts"	34✔
2	const { isNumber, isPlainObject, isString, isArray, isPrimitive, isBoolean } = is_what	34✔
3	import { Package, Installation, PackageRequirement } from "../types.ts"
4	import { provides as cache_provides, available as cache_available, runtime_env as cache_runtime_env, companions as cache_companions, dependencies as cache_dependencies } from "./useSyncCache.ts";	34✔
5	import SemVer, * as semver from "../utils/semver.ts"	34✔
6	import useMoustaches from "./useMoustaches.ts"	34✔
7	import { PkgxError } from "../utils/error.ts"	34✔
8	import { validate } from "../utils/misc.ts"	34✔
9	import * as pkgutils from "../utils/pkg.ts"	34✔
10	import useConfig from "./useConfig.ts"	34✔
11	import host from "../utils/host.ts"	34✔
12	import Path from "../utils/Path.ts"	34✔
13
14	export interface Interpreter {
15	project: string // FIXME: should probably be a stronger type
16	args: string[]
17	}
18
19	export class PantryError extends PkgxError	34✔
20	{}	34✔
21
22	export class PantryParseError extends PantryError {	34✔
23	project: string	×
24	path?: Path	×
25
26	constructor(project: string, path?: Path, cause?: unknown) {	×
27	super(`package.yml parse error: ${path ?? project}`)	×
28	this.project = project	×
29	this.path = path	×
30	this.cause = cause	×
31	}	×
32	}	34✔
33
34	export class PackageNotFoundError extends PantryError {	34✔
35	project: string	×
36	constructor(project: string) {	×
37	super(`pkg not found: ${project}`)	×
38	this.project = project	×
39	}	×
40	}	34✔
41
42	export class PantryNotFoundError extends PantryError {	34✔
43	constructor(path: Path) {	34✔
44	super(`pantry not found: ${path}`)	42✔
45	}	42✔
46	}	34✔
47
48	export default function usePantry() {	34✔
49	const prefix = useConfig().data.join("pantry/projects")	222✔
50	const is_cache_available = cache_available() && pantry_paths().length == 1	×
51
52	async function* ls(): AsyncGenerator<LsEntry> {	222✔
53	const seen = new Set()	246✔
54
55	for (const prefix of pantry_paths()) {	246✔
56	for await (const path of _ls_pantry(prefix)) {	246✔
57	const project = path.parent().relative({ to: prefix })	10,038✔
58	if (seen.insert(project).inserted) {	3,346✔
59	yield { project, path }	13,384✔
60	}	6,436✔
61	}	3,346✔
62	}	260✔
63	}	246✔
64
65	const project = (input: string \| { project: string }) => {	222✔
66	const project = isString(input) ? input : input.project	3,442✔
67
68	const yaml = (() => {	3,442✔
69	for (const prefix of pantry_paths()) {	6,662✔
70	if (!prefix.exists()) throw new PantryNotFoundError(prefix.parent())	×
71	const dir = prefix.join(project)	9,878✔
72	const filename = dir.join("package.yml")	9,878✔
73	if (!filename.exists()) continue	×
74
75	let memo: Promise<PlainObject> \| undefined	9,878✔
76
77	return () => memo ?? (memo = filename.readYAML()	✔
78	.then(validate.obj)	×
79	.catch(cause => { throw new PantryParseError(project, filename, cause) }))	×
80	}	9,878!
81	throw new PackageNotFoundError(project)	×
82	})()	×
83
84	const companions = async () => {	3,442✔
85	if (is_cache_available) {	×
86	return await cache_companions(project) ?? parse_pkgs_node((await yaml())["companions"])	×
87	} else {	×
88	return parse_pkgs_node((await yaml())["companions"])	6,452✔
89	}	6,452✔
90	}	3,442✔
91
92	const runtime_env = async (version: SemVer, deps: Installation[]) => {	3,442✔
93	const obj = await (async () => {	3,468✔
94	if (is_cache_available) {	×
95	const cached = await cache_runtime_env(project)	×
96	if (cached) return cached	×
97	}	×
98	const yml = await yaml()	3,494✔
99	return validate.obj(yml["runtime"]?.["env"] ?? {})	3,494✔
100	})()	3,468✔
101	return expand_env_obj(obj, { project, version }, deps)	13,872✔
102	}	3,442✔
103
104	const available = async (): Promise<boolean> => {	3,442✔
105	let { platforms } = await yaml()	3,448✔
106	if (!platforms) return true	3,448✔
107	if (isString(platforms)) platforms = [platforms]	×
108	if (!isArray(platforms)) throw new PantryParseError(project)	×
109	return platforms.includes(host().platform) \|\|platforms.includes(`${host().platform}/${host().arch}`)	×
110	}	3,442✔
111
112	const drydeps = async () => {	3,442✔
113	if (is_cache_available) {	×
114	return await cache_dependencies(project) ?? parse_pkgs_node((await yaml()).dependencies)	×
115	} else {	×
116	return parse_pkgs_node((await yaml()).dependencies)	6,480✔
117	}	6,480✔
118	}	3,442✔
119
120	const provides = async () => {	3,442✔
121	let node = (await yaml())["provides"]	6,534✔
122	if (!node) return []	6,534✔
123	if (isPlainObject(node)) {	6,534✔
124	node = node[host().platform]	6,556✔
125	}	6,556✔
126	if (!isArray(node)) throw new PantryParseError(project)	×
127
128	return node.compact(x => {	9,044✔
129	if (isPlainObject(x)) {	×
130	x = x["executable"]	×
131	}	×
132	if (isString(x)) {	16,479✔
133	if (x.startsWith("bin/")) return x.slice(4)	16,479✔
134	if (x.startsWith("sbin/")) return x.slice(5)	23,862✔
135	}	16,479✔
136	})	9,044✔
137	}	3,442✔
138
139	const provider = async () => {	3,442✔
140	for (const prefix of pantry_paths()) {	3,504✔
141	if (!prefix.exists()) continue	×
142	const dir = prefix.join(project)	3,504✔
143	const filename = dir.join("provider.yml")	3,504✔
144	if (!filename.exists()) continue	3,504✔
145	const yaml = validate.obj(await filename.readYAML())	3,515✔
146	const cmds = validate.arr<string>(yaml.cmds)	3,515✔
147	return (binname: string) => {	3,515✔
148	if (!cmds.includes(binname)) return	1,780✔
149	const args = yaml['args']	3,529✔
150	if (isPlainObject(args)) {	3,529✔
151	if (args[binname]) {	3,529✔
152	return get_args(args[binname])	3,533✔
153	} else {	3,529✔
154	return get_args(args['...'])	3,531✔
155	}	3,531✔
156	} else {	×
157	return get_args(args)	×
158	}	×
159	}	3,515✔
160	}	3,515✔
161	function get_args(input: unknown) {	3,555✔
162	if (isString(input)) {	3,561✔
163	return input.split(/\s+/)	3,565✔
164	} else {	3,561✔
165	return validate.arr<string>(input)	3,563✔
166	}	3,563✔
167	}	3,561✔
168	}	3,442✔
169
170	return {	3,442✔
171	companions,	3,442✔
172	runtime: {	3,442✔
173	env: runtime_env,	3,442✔
174	deps: drydeps	3,442✔
175	},	3,442✔
176	available,	3,442✔
177	provides,	3,442✔
178	provider,	3,442✔
179	yaml	3,442✔
180	}	3,442✔
181	}	222✔
182
183	/// finds a project that matches the input string on either name, display-name or FQD project name	222✔
184	/// - Returns: Project[] since there may by multiple matches, if you want a single match you should use `project()`	222✔
185	async function find(name: string) {	222✔
186	type Foo = ReturnType<typeof project> & LsEntry
187
188	//lol FIXME	224✔
189	name = pkgutils.parse(name).project	224✔
190
191	if (prefix.join(name).isDirectory()) {	×
192	const foo = project(name)	×
193	return [{...foo, project: name }]	×
194	}	×
195
196	/// only use cache if PKGX_PANTRY_PATH is not set	224✔
197	if (is_cache_available) {	×
198	const cached = await cache_provides(name)	×
199	if (cached?.length) {	×
200	return cached.map(x => ({	×
201	...project(x),	×
202	project: x	×
203	}))	×
204	}	×
205
206	// else we need to still check for display-names	×
207	}	×
208
209	name = name.toLowerCase()	224✔
210
211	//TODO not very performant due to serial awaits	224✔
212	const rv: Foo[] = []	224✔
213	for await (const pkg of ls()) {	224✔
214	const proj = {...project(pkg.project), ...pkg}	936✔
215	if (pkg.project.toLowerCase() == name) {	×
216	rv.push(proj)	×
217	continue	×
218	}	×
219	const yaml = await proj.yaml().swallow()	234✔
220	if (!yaml) {	×
221	console.warn("warn: parse failure:", pkg.project)	×
222	} else if (yaml["display-name"]?.toLowerCase() == name) {	×
223	rv.push(proj)	×
224	} else if ((await proj.provides()).map(x => x.toLowerCase()).includes(name)) {	✔
225	rv.push(proj)	236✔
226	}	236✔
227	}	234✔
228	return rv	224✔
229	}	224✔
230
231	async function which({ interprets: extension }: { interprets: string }): Promise<Interpreter \| undefined> {	222✔
232	if (extension[0] == '.') extension = extension.slice(1)	224✔
233	if (!extension) return	×
234	for await (const pkg of ls()) {	224✔
235	const yml = await project(pkg).yaml()	224✔
236	const node = yml["interprets"]	224✔
UNCOV 237	if (!isPlainObject(node)) continue	×
238	try {	224✔
239	const { extensions, args } = yml["interprets"]	224✔
240	if ((isString(extensions) && extensions === extension) \|\|	×
241	(isArray(extensions) && extensions.includes(extension))) {	×
242	return { project: pkg.project, args: isArray(args) ? args : [args] }	1,120!
243	}	224✔
244	} catch {	×
245	continue	×
246	}	×
247	}	224!
248	return undefined	×
249	}	×
250
251	const missing = () => {	222✔
252	try {	238✔
253	return !pantry_paths().some(x => x.exists())	238✔
254	} catch (e) {	238✔
255	if (e instanceof PantryNotFoundError) {	242✔
256	return true	242✔
257	} else {	×
258	throw e	×
259	}	×
260	}	242✔
261	}	222✔
262
263	return {	222✔
264	prefix,	222✔
265	which,	222✔
266	ls,	222✔
267	project,	222✔
268	find,	222✔
269	parse_pkgs_node,	222✔
270	expand_env_obj,	222✔
271	missing,	222✔
272	pantry_paths	222✔
273	}	222✔
274
275	function pantry_paths(): Path[] {	222✔
276	const rv: Path[] = []	3,544✔
277
278	if (prefix.isDirectory()) {	3,544✔
279	rv.push(prefix)	6,858✔
280	}	6,858✔
281	for (const path of useConfig().pantries.reverse()) {	3,544✔
282	rv.unshift(path.join("projects"))	3,546✔
283	}	3,546✔
284
285	if (rv.length == 0) {	3,544✔
286	throw new PantryNotFoundError(prefix)	6,870✔
287	}	6,870✔
288
289	return rv	10,176✔
290	}	3,544✔
291	}	222✔
292
293	// deno-lint-ignore no-explicit-any	2✔
294	export function parse_pkgs_node(node: any) {	34✔
295	if (!node) return []	6,082✔
296	node = validate.obj(node)	13,804✔
297	platform_reduce(node)	13,804✔
298
299	return Object.entries(node)	13,804✔
300	.compact(([project, constraint]) =>	13,804✔
301	validatePackageRequirement(project, constraint))	13,804✔
302	}	6,082✔
303
304	export function validatePackageRequirement(project: string, constraint: unknown): PackageRequirement {	34✔
305	if (isNumber(constraint)) {	4,417✔
306	constraint = `^${constraint}`	4,834✔
307	} else if (!isString(constraint)) {	×
308	throw new Error(`invalid constraint for ${project}: ${constraint}`)	×
309	}	×
310
311	constraint = semver.Range.parse(constraint as string)	4,417✔
312	if (!constraint) {	4,417✔
313	throw new PkgxError("invalid constraint for " + project + ": " + constraint)	4,421✔
314	}	4,421✔
315
316	return {	8,796✔
317	project,	8,796✔
318	constraint: constraint as semver.Range	8,796✔
319	}	8,796✔
320	}	4,417✔
321
322	/// expands platform specific keys into the object	2✔
323	/// expands inplace because JS is nuts and you have to suck it up	2✔
324	function platform_reduce(env: PlainObject) {	1,744✔
325	const sys = host()	1,744✔
326	for (const [key, value] of Object.entries(env)) {	1,744✔
327	const [os, arch] = (() => {	6,114✔
328	let match = key.match(/^(darwin\|linux)\/(aarch64\|x86-64)$/)	10,484✔
329	if (match) return [match[1], match[2]]	41,960✔
330	if ((match = key.match(/^(darwin\|linux)$/))) return [match[1]]	31,988✔
331	if ((match = key.match(/^(aarch64\|x86-64)$/))) return [,match[1]]	31,456✔
332	return []	14,576✔
333	})()	6,114✔
334
335	if (!os && !arch) continue	6,114✔
336	delete env[key]	10,740✔
337	if (os && os != sys.platform) continue	6,114✔
338	if (arch && arch != sys.arch) continue	3,057✔
339
340	const dict = validate.obj(value)	10,600✔
341	for (const [key, value] of Object.entries(dict)) {	10,462✔
342	// if user specifies an array then we assume we are supplementing	10,754✔
343	// otherwise we are replacing. If this is too magical let us know	10,754✔
344	if (isArray(value)) {	×
345	if (!env[key]) env[key] = []	×
346	else if (!isArray(env[key])) env[key] = [env[key]]	×
347	//TODO if all-platforms version comes after the specific then order accordingly	×
348	env[key].push(...value)	×
349	} else {	×
350	env[key] = value	10,754✔
351	}	10,754✔
352	}	10,754✔
353	}	10,600✔
354	}	1,744✔
355
356	export function expand_env_obj(env_: PlainObject, pkg: Package, deps: Installation[]): Record<string, string> {	34✔
357	const env = {...env_}	180✔
358
359	platform_reduce(env)	60✔
360
361	const rv: Record<string, string> = {}	60✔
362
363	for (let [key, value] of Object.entries(env)) {	60✔
364	if (isArray(value)) {	×
365	value = value.map(x => transform(x)).join(" ")	×
366	} else {	×
367	value = transform(value)	72✔
368	}	72✔
369
370	if (Deno.build.os == 'windows') {	×
371	// we standardize on UNIX directory separators	×
372	// NOTE hopefully this won’t break anything :/	×
373	value = value.replaceAll('/', '\\')	×
374	}	×
375
376	rv[key] = value	72✔
377	}	72✔
378
379	return rv	60✔
380
381	// deno-lint-ignore no-explicit-any	60✔
382	function transform(value: any): string {	60✔
383	if (!isPrimitive(value)) throw new PantryParseError(pkg.project, undefined, JSON.stringify(value))	×
384
385	if (isBoolean(value)) {	×
386	return value ? "1" : "0"	×
387	} else if (value === undefined \|\| value === null) {	×
388	return "0"	×
389	} else if (isString(value)) {	×
390	const mm = useMoustaches()	72✔
391	const home = Path.home().string	72✔
392	const obj = [	72✔
393	{ from: 'home', to: home } // remove, stick with just ~	288✔
394	]	72✔
395	obj.push(...mm.tokenize.all(pkg, deps))	72✔
396	return mm.apply(value, obj)	72✔
397	} else if (isNumber(value)) {	×
398	return value.toString()	×
399	}	×
400
401	const e = new Error("unexpected error")	×
402	e.cause = value	×
403	throw e	×
404	}	×
405	}	60✔
406
407	interface LsEntry {
408	project: string
409	path: Path
410	}
411
412	async function* _ls_pantry(dir: Path): AsyncGenerator<Path> {	4,262✔
413	if (!dir.isDirectory()) throw new PantryNotFoundError(dir)	×
414
415	for await (const [path, { name, isDirectory }] of dir.ls()) {	4,262✔
416	if (isDirectory) {	12,409✔
417	for await (const x of _ls_pantry(path)) {	16,613✔
418	yield x	22,345✔
419	}	28,067✔
420	} else if (name === "package.yml" \|\| name === "package.yaml") {	12,409✔
421	yield path	19,452✔
422	}	22,542✔
423	}	12,409✔
424	}	4,262✔

pkgxdev / libpkgx / 11482869644

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous