10407549248

Committed 15 Aug 2024 05:06PM UTC coverage: 91.254% (+0.04%) from 91.216%

Build # 10407549248

Build Type

Pull #1361

github

Committed by

web-flow

Commit Message

Merge 4697e08fa into 0eee1d346

Pull Request Pull Request #1361: Bulleted arrays with `.` or `•`

Run Details

2772 of 3009 branches covered (92.12%)

Branch coverage included in aggregate %.

148 of 149 new or added lines in 2 files covered. (99.33%)

43 existing lines in 3 files now uncovered.

15467 of 16978 relevant lines covered (91.1%)

17682.73 hits per line

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

85.0

/source/main.civet

import { parse, parseProgram, ParseError, getConfig } from "./parser.hera"
import generate, { prune } from "./generate.civet"
import * as lib from "./parser/lib.civet"
import * as sourcemap from "./sourcemap.civet"
{ SourceMap } := sourcemap
export { parse, parseProgram, ParseError, generate, prune, lib, sourcemap, SourceMap }
type { BlockStatement } from "./types.hera"
export type BlockStatement

import StateCache from "./state-cache.civet"

export class ParseErrors extends Error
  name = "ParseErrors"
  errors: ParseError[]
  @(errors: ParseError[])
    message := errors.map(.message).join("\n")
    super errors.map(.message).join("\n")
    @message = message
    @errors = errors

// Need to no-cache any rule that directly modifies parser state
// indentation stack, jsx stack, etc.

uncacheable := new Set [
  // Meta
  "DebugHere"
  "Init"
  "Program"
  "Reset"

  // Indentation
  // We need to no-cache the state modifying rules up to the point where they
  // balance within a parent so PushIndent needs to be marked no-cache even
  // though it only calls TrackIndented which does the actual work.
  "PushIndent"
  "PopIndent"
  "TrackIndented"
  "BulletIndent"

  // JSX
  "PushJSXOpeningElement"
  "PushJSXOpeningFragment"
  "PopJSXStack"

  // State
  "AllowAll"
  "AllowClassImplicitCall"
  "AllowBracedApplication"
  "AllowIndentedApplication"
  "AllowMultiLineImplicitObjectLiteral"
  "AllowNewlineBinaryOp"
  "AllowTrailingMemberProperty"

  "ForbidClassImplicitCall"
  "ForbidBracedApplication"
  "ForbidIndentedApplication"
  "ForbidMultiLineImplicitObjectLiteral"
  "ForbidNewlineBinaryOp"
  "ForbidTrailingMemberProperty"

  "RestoreAll"
  "RestoreClassImplicitCall"
  "RestoreMultiLineImplicitObjectLiteral"
  "RestoreBracedApplication"
  "RestoreIndentedApplication"
  "RestoreTrailingMemberProperty"
  "RestoreNewlineBinaryOp"

]

export type CompilerOptions
  filename?: string
  sourceMap?: boolean
  inlineMap?: boolean
  ast?: boolean | "raw"
  js?: boolean
  sync?: boolean
  noCache?: boolean
  hits?: string
  trace?: string
  parseOptions?:
    coffeeCompat?: boolean
    comptime?: boolean
  // Specifying an empty array will prevent ParseErrors from being thrown
  errors?: ParseError[]

type CompileOutput<T extends CompilerOptions> =
  T extends { ast: true } ? BlockStatement : T extends { sourceMap: true } ? { code: string, sourceMap: ReturnType<typeof SourceMap> } : string

export function compile<const T extends CompilerOptions>(src: string, options?: T): T extends { sync: true } ? CompileOutput<T> : Promise<CompileOutput<T>>
  unless options
    options = {} as T
  else
    options = {...options}

  // Handle undefined parseOptions, and avoid mutating the original object
  options.parseOptions = {...options.parseOptions}

  filename := options.filename or "unknown"

  if filename.endsWith('.coffee') and not /^(#![^\r\n]*(\r\n|\n|\r))?\s*['"]civet/.test src
    options.parseOptions.coffeeCompat = true

  {hits, trace, noCache} := options

  let events: CacheEvents | undefined
  unless noCache
    events = makeCache {
      hits: !!hits
      trace: !!trace
    }

  let ast

  try
    //@ts-ignore
    ast = parseProgram(src, {
      options.parseOptions
      options.sync
      filename
      events
    })
  finally
    if hits or trace
      import("node:fs").then ({ writeFileSync }) ->
        if { logs } := events?.meta
          if trace
            writeFileSync trace, logs.join "\n"

        if hits
          if hitData := events?.meta.hits
            total .= 0
            data := [...hitData.entries()]

            // sort hit count and write to hits.out
            counts := data
            .sort ([, a], [, b]) => b - a
            .map ([k, v]) =>
              total+=v
              `${k}: ${v}`
            .join "\n"

            hitSummary := ```
              Total: ${total}

              ${counts}
            ```

            writeFileSync hits, hitSummary

  throwOnErrors := not options.errors?

  function rest(ast)
    options = options!
    ast = prune ast unless options.ast is "raw"

    if options.ast
      return ast

    function checkErrors
      return unless throwOnErrors
      options = options!
      if options.errors?.length
        throw new ParseErrors options.errors

    if options.sourceMap or options.inlineMap
      //@ts-ignore sourceMap option for generate
      options.sourceMap = SourceMap(src)
      code := generate ast, options
      checkErrors()

      if options.inlineMap
        //@ts-ignore
        return SourceMap.remap code, options.sourceMap, filename, filename + '.tsx'
      else
        return {
          code,
          sourceMap: options.sourceMap
        }

    result := generate ast, options

    // If there are errors, run generate again with sourcemap to get locations
    if options!.errors?.length
      delete options.errors
      //@ts-ignore sourceMap option for generate
      options.sourceMap = SourceMap(src)
      generate ast, options
      checkErrors()

    return result

  if ast.then?
    ast.then rest
  else
    rest ast

type CacheKey = [string, number, number, string]

type ParseState =
  input: string
  pos: number

type ParseResult = {
  pos: number
  value: unknown
} | undefined

type MetaData
  hits?: Map<string, number>
  logs?: string[]

type CacheOptions
  hits?: boolean | undefined
  trace?: boolean | undefined

type CacheEvents
  meta: MetaData
  enter: (ruleName: string, state: ParseState) => { cache: ParseResult } | undefined
  exit: (ruleName: string, state: ParseState, result: ParseResult) => void

makeCache := ({hits, trace}: CacheOptions = {}): CacheEvents ->
  meta: MetaData := {}
  let hitCount: Map<string, number>
  if hits
    hitCount = new Map
    meta.hits = hitCount

  let logs: string[]
  if trace
    logs = []
    meta.logs = logs

  stateCache := new StateCache<ParseResult>
  getStateKey: () => [number, string] .= null!

  stack: string[] := []

  events := {
    meta
    enter: (ruleName: string, state: ParseState) ->
      hitCount.set ruleName, (hitCount.get(ruleName) or 0) + 1 if hits

      return if uncacheable.has(ruleName)

      [stateKey, tagKey] := getStateKey()
      key: CacheKey := [tagKey, stateKey, state.pos, ruleName ]

      // We cache `undefined` when a rule fails to match so we need to use `has` here.
      if stateCache.has(key)
        result := stateCache.get(key)
        if trace
          logs.push "".padStart(stack.length * 2, " ") + ruleName + ":" + state.pos + "💰" + (if result then "✅" else "❌")
        return {
          cache: if result then { ...result }
        }

      if trace
        logs.push "".padStart(stack.length * 2, " ") + ruleName + ":" + state.pos + "\u2192"
        stack.push ruleName

      return

    exit: (ruleName: string, state: ParseState, result: ParseResult) ->
      // special hack to get access to parser state
      if ruleName is "Reset"
        //@ts-ignore
        { getStateKey } = result.value

      if !uncacheable.has(ruleName)
        [stateKey, tagKey] := getStateKey()
        key: CacheKey := [tagKey, stateKey, state.pos, ruleName ]
        stateCache.set(key, result)

      //@ts-ignore
      if getConfig().verbose and result
        console.log `Parsed ${JSON.stringify state.input[state.pos...result.pos]} [pos ${state.pos}-${result.pos}] as ${ruleName}`//, JSON.stringify(result.value)

      if trace
        stack.pop()
        logs.push "".padStart(stack.length * 2, " ") + ruleName + ":" + state.pos + " " + (if result then "✅" else "❌")

      return
  }

  return events

export isCompileError = (err: ???): err is ParseError | ParseErrors ->
  err <? ParseError or err <? ParseErrors
  //[err.message, err.name, err.filename, err.line, err.column, err.offset].every & !== undefined

export default { parse, parseProgram, ParseError, ParseErrors, generate, sourcemap, SourceMap, compile, isCompileError }

1	import { parse, parseProgram, ParseError, getConfig } from "./parser.hera"	1✔
2	import generate, { prune } from "./generate.civet"	1✔
3	import * as lib from "./parser/lib.civet"	1✔
4	import * as sourcemap from "./sourcemap.civet"	1✔
5	{ SourceMap } := sourcemap	1✔
6	export { parse, parseProgram, ParseError, generate, prune, lib, sourcemap, SourceMap }	1✔
7	type { BlockStatement } from "./types.hera"	1✔
8	export type BlockStatement	1✔
9		1✔
10	import StateCache from "./state-cache.civet"	1✔
11		1✔
12	export class ParseErrors extends Error	1✔
13	name = "ParseErrors"	33✔
14	errors: ParseError[]	33✔
15	@(errors: ParseError[])	33✔
16	message := errors.map(.message).join("\n")	33✔
17	super errors.map(.message).join("\n")	33✔
18	@message = message	33✔
19	@errors = errors	33✔
20		1✔
21	// Need to no-cache any rule that directly modifies parser state	1✔
22	// indentation stack, jsx stack, etc.	1✔
23		1✔
24	uncacheable := new Set [	1✔
25	// Meta	1✔
26	"DebugHere"	1✔
27	"Init"	1✔
28	"Program"	1✔
29	"Reset"	1✔
30		1✔
31	// Indentation	1✔
32	// We need to no-cache the state modifying rules up to the point where they	1✔
33	// balance within a parent so PushIndent needs to be marked no-cache even	1✔
34	// though it only calls TrackIndented which does the actual work.	1✔
35	"PushIndent"	1✔
36	"PopIndent"	1✔
37	"TrackIndented"	1✔
38	"BulletIndent"	1✔
39		1✔
40	// JSX	1✔
41	"PushJSXOpeningElement"	1✔
42	"PushJSXOpeningFragment"	1✔
43	"PopJSXStack"	1✔
44		1✔
45	// State	1✔
46	"AllowAll"	1✔
47	"AllowClassImplicitCall"	1✔
48	"AllowBracedApplication"	1✔
49	"AllowIndentedApplication"	1✔
50	"AllowMultiLineImplicitObjectLiteral"	1✔
51	"AllowNewlineBinaryOp"	1✔
52	"AllowTrailingMemberProperty"	1✔
53		1✔
54	"ForbidClassImplicitCall"	1✔
55	"ForbidBracedApplication"	1✔
56	"ForbidIndentedApplication"	1✔
57	"ForbidMultiLineImplicitObjectLiteral"	1✔
58	"ForbidNewlineBinaryOp"	1✔
59	"ForbidTrailingMemberProperty"	1✔
60		1✔
61	"RestoreAll"	1✔
62	"RestoreClassImplicitCall"	1✔
63	"RestoreMultiLineImplicitObjectLiteral"	1✔
64	"RestoreBracedApplication"	1✔
65	"RestoreIndentedApplication"	1✔
66	"RestoreTrailingMemberProperty"	1✔
67	"RestoreNewlineBinaryOp"	1✔
68		1✔
69	]	1✔
70		1✔
71	export type CompilerOptions	1✔
72	filename?: string	1✔
73	sourceMap?: boolean	1✔
74	inlineMap?: boolean	1✔
75	ast?: boolean \| "raw"	1✔
76	js?: boolean	1✔
77	sync?: boolean	1✔
78	noCache?: boolean	1✔
79	hits?: string	1✔
80	trace?: string	1✔
81	parseOptions?:	1✔
82	coffeeCompat?: boolean	1✔
83	comptime?: boolean	1✔
84	// Specifying an empty array will prevent ParseErrors from being thrown	1✔
85	errors?: ParseError[]	1✔
86		1✔
87	type CompileOutput<T extends CompilerOptions> =	1✔
88	T extends { ast: true } ? BlockStatement : T extends { sourceMap: true } ? { code: string, sourceMap: ReturnType<typeof SourceMap> } : string	1✔
89		1✔
90	export function compile<const T extends CompilerOptions>(src: string, options?: T): T extends { sync: true } ? CompileOutput<T> : Promise<CompileOutput<T>>	1✔
91	unless options	2,512✔
92	options = {} as T	68✔
93	else	2,444✔
94	options = {...options}	2,444✔
95		2,512✔
96	// Handle undefined parseOptions, and avoid mutating the original object	2,512✔
97	options.parseOptions = {...options.parseOptions}	2,512✔
98		2,512✔
99	filename := options.filename or "unknown"	2,512✔
100		2,512✔
101	if filename.endsWith('.coffee') and not /^(#![^\r\n](\r\n\|\n\|\r))?\s['"]civet/.test src	2,512✔
102	options.parseOptions.coffeeCompat = true	1✔
103		2,512✔
104	{hits, trace, noCache} := options	2,512✔
105		2,512✔
106	let events: CacheEvents \| undefined	2,512✔
107	unless noCache	2,512✔
108	events = makeCache {	2,512✔
109	hits: !!hits	2,512✔
110	trace: !!trace	2,512✔
111	}	2,512✔
112		2,512✔
113	let ast	2,512✔
114		2,512✔
115	try	2,512✔
116	//@ts-ignore	2,512✔
117	ast = parseProgram(src, {	2,512✔
118	options.parseOptions	2,512✔
119	options.sync	2,512✔
120	filename	2,512✔
121	events	2,512✔
122	})	2,512✔
123	finally	2,512✔
124	if hits or trace	2,512✔
125	import("node:fs").then ({ writeFileSync }) ->	×
126	if { logs } := events?.meta	×
127	if trace	×
128	writeFileSync trace, logs.join "\n"	×
129		×
130	if hits	×
131	if hitData := events?.meta.hits	×
132	total .= 0	×
133	data := [...hitData.entries()]	×
134		×
135	// sort hit count and write to hits.out	×
136	counts := data	×
137	.sort ([, a], [, b]) => b - a	×
138	.map ([k, v]) =>	×
139	total+=v	×
140	`${k}: ${v}`	×
141	.join "\n"	×
142		×
143	hitSummary := ```	×
144	Total: ${total}	×
145		×
146	${counts}	×
147	```	×
148		×
149	writeFileSync hits, hitSummary	×
150		2,474✔
151	throwOnErrors := not options.errors?	2,474✔
152		2,474✔
153	function rest(ast)	2,474✔
154	options = options!	2,474✔
155	ast = prune ast unless options.ast is "raw"	2,474✔
156		2,474✔
157	if options.ast	2,474✔
158	return ast	×
159		2,474✔
160	function checkErrors	2,474✔
161	return unless throwOnErrors	37!
162	options = options!	37✔
163	if options.errors?.length	37✔
164	throw new ParseErrors options.errors	33✔
165		2,474✔
166	if options.sourceMap or options.inlineMap	2,474✔
167	//@ts-ignore sourceMap option for generate	5✔
168	options.sourceMap = SourceMap(src)	5✔
169	code := generate ast, options	5✔
170	checkErrors()	5✔
171		5✔
172	if options.inlineMap	5✔
173	//@ts-ignore	×
174	return SourceMap.remap code, options.sourceMap, filename, filename + '.tsx'	×
175	else	4✔
176	return {	4✔
177	code,	4✔
178	sourceMap: options.sourceMap	4✔
179	}	4✔
180		2,469✔
181	result := generate ast, options	2,469✔
182		2,469✔
183	// If there are errors, run generate again with sourcemap to get locations	2,469✔
184	if options!.errors?.length	2,474✔
185	delete options.errors	32✔
186	//@ts-ignore sourceMap option for generate	32✔
187	options.sourceMap = SourceMap(src)	32✔
188	generate ast, options	32✔
189	checkErrors()	32✔
190		2,437✔
191	return result	2,437✔
192		2,474✔
193	if ast.then?	2,474✔
194	ast.then rest	2,461✔
195	else	13✔
196	rest ast	13✔
197		1✔
198	type CacheKey = [string, number, number, string]	1✔
199		1✔
200	type ParseState =	1✔
201	input: string	1✔
202	pos: number	1✔
203		1✔
204	type ParseResult = {	1✔
205	pos: number	1✔
206	value: unknown	1✔
207	} \| undefined	1✔
208		1✔
209	type MetaData	1✔
210	hits?: Map<string, number>	1✔
211	logs?: string[]	1✔
212		1✔
213	type CacheOptions	1✔
214	hits?: boolean \| undefined	1✔
215	trace?: boolean \| undefined	1✔
216		1✔
217	type CacheEvents	1✔
218	meta: MetaData	1✔
219	enter: (ruleName: string, state: ParseState) => { cache: ParseResult } \| undefined	1✔
220	exit: (ruleName: string, state: ParseState, result: ParseResult) => void	1✔
221		1✔
222	makeCache := ({hits, trace}: CacheOptions = {}): CacheEvents ->	1✔
223	meta: MetaData := {}	2,512✔
224	let hitCount: Map<string, number>	2,512✔
225	if hits	2,512✔
226	hitCount = new Map	×
227	meta.hits = hitCount	×
228		2,512✔
229	let logs: string[]	2,512✔
230	if trace	2,512✔
231	logs = []	×
232	meta.logs = logs	×
233		2,512✔
234	stateCache := new StateCache<ParseResult>	2,512✔
235	getStateKey: () => [number, string] .= null!	2,512✔
236		2,512✔
237	stack: string[] := []	2,512✔
238		2,512✔
239	events := {	2,512✔
240	meta	2,512✔
241	enter: (ruleName: string, state: ParseState) ->	2,512✔
242	hitCount.set ruleName, (hitCount.get(ruleName) or 0) + 1 if hits	4,104,850!
243		4,104,850✔
244	return if uncacheable.has(ruleName)	4,104,850✔
245		3,971,420✔
246	[stateKey, tagKey] := getStateKey()	3,971,420✔
247	key: CacheKey := [tagKey, stateKey, state.pos, ruleName ]	3,971,420✔
248		3,971,420✔
249	// We cache `undefined` when a rule fails to match so we need to use `has` here.	3,971,420✔
250	if stateCache.has(key)	3,971,420✔
251	result := stateCache.get(key)	1,111,135✔
252	if trace	1,111,135✔
NEW 253	logs.push "".padStart(stack.length * 2, " ") + ruleName + ":" + state.pos + "💰" + (if result then "✅" else "❌")	×
254	return {	1,111,135✔
255	cache: if result then { ...result }	1,111,135✔
256	}	1,111,135✔
257		2,860,285✔
258	if trace	2,860,285✔
259	logs.push "".padStart(stack.length * 2, " ") + ruleName + ":" + state.pos + "\u2192"	×
260	stack.push ruleName	×
261		2,860,285✔
262	return	2,860,285✔
263		2,512✔
264	exit: (ruleName: string, state: ParseState, result: ParseResult) ->	2,512✔
265	// special hack to get access to parser state	2,993,715✔
266	if ruleName is "Reset"	2,993,715✔
267	//@ts-ignore	2,512✔
268	{ getStateKey } = result.value	2,512✔
269		2,993,715✔
270	if !uncacheable.has(ruleName)	2,993,715✔
271	[stateKey, tagKey] := getStateKey()	2,860,285✔
272	key: CacheKey := [tagKey, stateKey, state.pos, ruleName ]	2,860,285✔
273	stateCache.set(key, result)	2,860,285✔
274		2,993,715✔
275	//@ts-ignore	2,993,715✔
276	if getConfig().verbose and result	2,993,715!
277	console.log `Parsed ${JSON.stringify state.input[state.pos...result.pos]} [pos ${state.pos}-${result.pos}] as ${ruleName}`//, JSON.stringify(result.value)	×
278		2,993,715✔
279	if trace	2,993,715✔
280	stack.pop()	×
281	logs.push "".padStart(stack.length * 2, " ") + ruleName + ":" + state.pos + " " + (if result then "✅" else "❌")	×
282		2,993,715✔
283	return	2,993,715✔
284	}	2,512✔
285		2,512✔
286	return events	2,512✔
287		1✔
288	export isCompileError = (err: ???): err is ParseError \| ParseErrors ->	1✔
289	err <? ParseError or err <? ParseErrors	×
290	//[err.message, err.name, err.filename, err.line, err.column, err.offset].every & !== undefined	1✔
291		1✔
292	export default { parse, parseProgram, ParseError, ParseErrors, generate, sourcemap, SourceMap, compile, isCompileError }	1✔

DanielXMoore / Civet / 10407549248

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