10737049447

Committed 06 Sep 2024 10:48AM UTC coverage: 82.996% (-1.4%) from 84.382%

Build # 10737049447

Build Type

Pull #75

github

Committed by

web-flow

Commit Message

Merge 6262c9479 into 2aec73a0c

Pull Request Pull Request #75: Stuff

Run Details

556 of 734 branches covered (75.75%)

Branch coverage included in aggregate %.

16 of 17 new or added lines in 7 files covered. (94.12%)

72 existing lines in 6 files now uncovered.

2441 of 2877 relevant lines covered (84.85%)

2630.67 hits per line

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

68.99

/src/hooks/useSyncCache.ts

import { Database } from "../../vendor/sqlite3@0.10.0/mod.ts";
import * as pkgutils from "../utils/pkg.ts";
import usePantry from "./usePantry.ts";
import useConfig from "./useConfig.ts";

export default async function() {
  if (Deno.build.os == 'windows') return

  const path = useConfig().cache.join('pantry.db').rm()  // delete it first so pantry instantiation doesn't use cache
  const { ls, ...pantry } = usePantry()

  const sqlite3 = (await install_sqlite())?.string
  if (!sqlite3) return
  const db = new Database(path.string, { sqlite3 })

  // unique or don’t insert what is already there or just dump tables first perhaps

  try {
    await db.transaction(async () => {
      db.exec(`
        DROP TABLE IF EXISTS provides;
        DROP TABLE IF EXISTS dependencies;
        DROP TABLE IF EXISTS companions;
        DROP TABLE IF EXISTS runtime_env;
        CREATE TABLE provides (
          project TEXT,
          program TEXT
        );
        CREATE TABLE dependencies (
          project TEXT,
          pkgspec TEXT
        );
        CREATE TABLE companions (
          project TEXT,
          pkgspec TEXT
        );
        CREATE TABLE runtime_env (
          project TEXT,
          envline TEXT
        );
        CREATE INDEX idx_project ON provides(project);
        CREATE INDEX idx_program ON provides(program);
        CREATE INDEX idx_project_dependencies ON dependencies(project);
        CREATE INDEX idx_project_companions ON companions(project);
        `);

      for await (const pkg of ls()) {
        if (!pkg.path.string.startsWith(pantry.prefix.string)) {
          // don’t cache PKGX_PANTRY_PATH additions
          continue;
        }

        try {
          const project = pantry.project(pkg.project)
          const [programs, deps, companions, yaml] = await Promise.all([
            project.provides(),
            project.runtime.deps(),
            project.companions(),
            project.yaml()
          ])

          for (const program of programs) {
            db.exec(`INSERT INTO provides (project, program) VALUES ('${pkg.project}', '${program}');`);
          }

          for (const dep of deps) {
            db.exec(`INSERT INTO dependencies (project, pkgspec) VALUES ('${pkg.project}', '${pkgutils.str(dep)}')`);
          }

          for (const companion of companions) {
            db.exec(`INSERT INTO companions (project, pkgspec) VALUES ('${pkg.project}', '${pkgutils.str(companion)}')`);
          }

          for (const [key, value] of Object.entries(yaml.runtime?.env ?? {})) {
            db.exec(`INSERT INTO runtime_env (project, envline) VALUES ('${pkg.project}', '${key}=${value}')`);
          }
        } catch {
          console.warn("corrupt yaml", pkg.path)
        }
      }
    })()
  } catch (err) {
    path.rm()
    throw err
  } finally {
    db.close();
  }
}

export async function provides(program: string) {
  const db = await _db()
  if (!db) return
  try {
   return db.sql`SELECT project FROM provides WHERE program = ${program}`.map(x => x.project);
  } finally {
    db.close()
  }
}

export async function dependencies(project: string) {
  const db = await _db()
  if (!db) return
  try {
    return db.sql`SELECT pkgspec FROM dependencies WHERE project = ${project}`.map(x => pkgutils.parse(x.pkgspec));
  } finally {
    db.close()
  }
}

export async function completion(prefix: string) {
  const db = await _db()
  try {
    return db?.prepare(`SELECT program FROM provides WHERE program LIKE '${prefix}%'`).value<[string]>()!;
  } finally {
    db?.close()
  }
}

/// is the cache available?
export function available() {
  if (Deno.build.os == 'windows') {
    return false
  } else {
    const path = useConfig().cache.join('pantry.db')
    return path.isFile()
  }
}

export async function companions(project: string) {
  const db = await _db()
  if (!db) return
  try {
    return db.sql`SELECT pkgspec FROM companions WHERE project = ${project}`.map(x => pkgutils.parse(x.pkgspec));
  } finally {
    db.close()
  }
}

export async function runtime_env(project: string) {
  const db = await _db()
  if (!db) return
  try {
    const rv: Record<string, string> = {}
    for (const {envline: line} of db.sql`SELECT envline FROM runtime_env WHERE project = ${project}`) {
      const [key, ...rest] = line.split("=")
      rv[key] = rest.join('=')
    }
    return rv
  } finally {
    db.close()
  }
}

import useCellar from "./useCellar.ts"

async function _db() {
  if (Deno.build.os == 'windows') return
  const path = useConfig().cache.join('pantry.db')
  if (!path.isFile()) return
  const sqlite = await useCellar().has({ project: "sqlite.org", constraint: new semver.Range('*') })
  if (!sqlite) return
  const ext = host().platform == 'darwin' ? 'dylib' : 'so'
  return new Database(path.string, {readonly: true, sqlite3: sqlite.path.join(`lib/libsqlite3.${ext}`).string})
}

import install from "../porcelain/install.ts"
import host from "../utils/host.ts";
import Path from "../utils/Path.ts";
import { semver } from "../../mod.ts";

async function install_sqlite(): Promise<Path | undefined> {
  const foo = await install("sqlite.org")
  for (const bar of foo) {
    if (bar.pkg.project == 'sqlite.org') {
      const ext = host().platform == 'darwin' ? 'dylib' : 'so'
      return bar.path.join(`lib/libsqlite3.${ext}`)
    }
  }
}

1	import { Database } from "../../vendor/sqlite3@0.10.0/mod.ts";	34✔
2	import * as pkgutils from "../utils/pkg.ts";	34✔
3	import usePantry from "./usePantry.ts";	34✔
4	import useConfig from "./useConfig.ts";	34✔
5
6	export default async function() {	34✔
7	if (Deno.build.os == 'windows') return	×
8
9	const path = useConfig().cache.join('pantry.db').rm() // delete it first so pantry instantiation doesn't use cache	36✔
10	const { ls, ...pantry } = usePantry()	36✔
11
12	const sqlite3 = (await install_sqlite())?.string	36✔
13	if (!sqlite3) return	×
14	const db = new Database(path.string, { sqlite3 })	108✔
15
16	// unique or don’t insert what is already there or just dump tables first perhaps	36✔
17
18	try {	36✔
19	await db.transaction(async () => {	36✔
20	db.exec(`	38✔
21	DROP TABLE IF EXISTS provides;
22	DROP TABLE IF EXISTS dependencies;
23	DROP TABLE IF EXISTS companions;
24	DROP TABLE IF EXISTS runtime_env;
25	CREATE TABLE provides (
26	project TEXT,
27	program TEXT
28	);
29	CREATE TABLE dependencies (
30	project TEXT,
31	pkgspec TEXT
32	);
33	CREATE TABLE companions (
34	project TEXT,
35	pkgspec TEXT
36	);
37	CREATE TABLE runtime_env (
38	project TEXT,
39	envline TEXT
40	);
41	CREATE INDEX idx_project ON provides(project);
42	CREATE INDEX idx_program ON provides(program);
43	CREATE INDEX idx_project_dependencies ON dependencies(project);
44	CREATE INDEX idx_project_companions ON companions(project);
45	`);	38✔
46
47	for await (const pkg of ls()) {	38✔
48	if (!pkg.path.string.startsWith(pantry.prefix.string)) {	×
49	// don’t cache PKGX_PANTRY_PATH additions
50	continue;	×
51	}	×
52
53	try {	2,956✔
54	const project = pantry.project(pkg.project)	2,956✔
55	const [programs, deps, companions, yaml] = await Promise.all([	2,956✔
56	project.provides(),	2,956✔
57	project.runtime.deps(),	2,956✔
58	project.companions(),	2,956✔
59	project.yaml()	2,956✔
60	])	2,956✔
61
62	for (const program of programs) {	2,956✔
63	db.exec(`INSERT INTO provides (project, program) VALUES ('${pkg.project}', '${program}');`);	10,155✔
64	}	10,155✔
65
66	for (const dep of deps) {	2,956✔
67	db.exec(`INSERT INTO dependencies (project, pkgspec) VALUES ('${pkg.project}', '${pkgutils.str(dep)}')`);	7,047✔
68	}	7,047✔
69
70	for (const companion of companions) {	2,956✔
71	db.exec(`INSERT INTO companions (project, pkgspec) VALUES ('${pkg.project}', '${pkgutils.str(companion)}')`);	3,042✔
72	}	3,042✔
73
74	for (const [key, value] of Object.entries(yaml.runtime?.env ?? {})) {	2,956✔
75	db.exec(`INSERT INTO runtime_env (project, envline) VALUES ('${pkg.project}', '${key}=${value}')`);	3,262✔
76	}	3,262✔
77	} catch {	×
78	console.warn("corrupt yaml", pkg.path)	×
79	}	×
80	}	2,956✔
81	})()	36✔
82	} catch (err) {	×
83	path.rm()	×
84	throw err	×
85	} finally {	×
86	db.close();	36✔
87	}	36✔
88	}	36✔
89
90	export async function provides(program: string) {	34✔
91	const db = await _db()	36✔
92	if (!db) return	×
93	try {	36✔
94	return db.sql`SELECT project FROM provides WHERE program = ${program}`.map(x => x.project);	36✔
95	} finally {	36✔
96	db.close()	36✔
97	}	36✔
98	}	36✔
99
100	export async function dependencies(project: string) {	×
101	const db = await _db()	×
102	if (!db) return	×
103	try {	×
104	return db.sql`SELECT pkgspec FROM dependencies WHERE project = ${project}`.map(x => pkgutils.parse(x.pkgspec));	×
105	} finally {	×
106	db.close()	×
107	}	×
108	}	×
109
110	export async function completion(prefix: string) {	34✔
111	const db = await _db()	36✔
112	try {	36✔
113	return db?.prepare(`SELECT program FROM provides WHERE program LIKE '${prefix}%'`).value<[string]>()!;	36✔
114	} finally {	36✔
115	db?.close()	36✔
116	}	36✔
117	}	36✔
118
119	/// is the cache available?	2✔
120	export function available() {	34✔
UNCOV 121	if (Deno.build.os == 'windows') {	×
UNCOV 122	return false	×
123	} else {	×
124	const path = useConfig().cache.join('pantry.db')	242✔
125	return path.isFile()	242✔
126	}	242✔
127	}	242✔
128
129	export async function companions(project: string) {	34✔
130	const db = await _db()	36✔
131	if (!db) return	×
132	try {	36✔
133	return db.sql`SELECT pkgspec FROM companions WHERE project = ${project}`.map(x => pkgutils.parse(x.pkgspec));	36✔
134	} finally {	36✔
135	db.close()	36✔
136	}	36✔
137	}	36✔
138
139	export async function runtime_env(project: string) {	34✔
140	const db = await _db()	36✔
141	if (!db) return	×
142	try {	36✔
143	const rv: Record<string, string> = {}	36✔
144	for (const {envline: line} of db.sql`SELECT envline FROM runtime_env WHERE project = ${project}`) {	36✔
145	const [key, ...rest] = line.split("=")	36✔
146	rv[key] = rest.join('=')	36✔
147	}	36✔
148	return rv	36✔
149	} finally {	36✔
150	db.close()	36✔
151	}	36✔
152	}	36✔
153
154	import useCellar from "./useCellar.ts"	34✔
155
156	async function _db() {	42✔
157	if (Deno.build.os == 'windows') return	×
158	const path = useConfig().cache.join('pantry.db')	42✔
159	if (!path.isFile()) return	×
160	const sqlite = await useCellar().has({ project: "sqlite.org", constraint: new semver.Range('*') })	168✔
161	if (!sqlite) return	×
162	const ext = host().platform == 'darwin' ? 'dylib' : 'so'	×
163	return new Database(path.string, {readonly: true, sqlite3: sqlite.path.join(`lib/libsqlite3.${ext}`).string})	168✔
164	}	42✔
165
166	import install from "../porcelain/install.ts"	34✔
167	import host from "../utils/host.ts";	34✔
168	import Path from "../utils/Path.ts";
169	import { semver } from "../../mod.ts";	34✔
170
171	async function install_sqlite(): Promise<Path \| undefined> {	36✔
172	const foo = await install("sqlite.org")	36✔
173	for (const bar of foo) {	36✔
174	if (bar.pkg.project == 'sqlite.org') {	39✔
175	const ext = host().platform == 'darwin' ? 'dylib' : 'so'	×
176	return bar.path.join(`lib/libsqlite3.${ext}`)	40✔
177	}	40✔
178	}	39!
179	}	36✔

pkgxdev / libpkgx / 10737049447

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