4190369997

Build # 4190369997

Build Type

push

github

Committed by Juan Manuel Castillo

Commit Message

add "jsonKeyCase":"snake_case" example in test workspace

Run Details

1490 of 4650 branches covered (32.04%)

Branch coverage included in aggregate %.

5444 of 12875 relevant lines covered (42.28%)

228.2 hits per line

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

61.97

/src/utils.ts

import Ajv, {
  ErrorObject,
  JTDSchemaType as AjvJTDSchemaType,
  ValidateFunction,
} from "ajv/dist/jtd";
import AjvJSONSchema, { JSONSchemaType as AjvJSONSchemaType } from "ajv";
import { camelCase, constantCase, pascalCase, snakeCase } from "change-case";
import * as yaml from "yaml";
import JSON5 from "json5";
import * as JSONTypeDefSchema_ from "./json-type-definition/json-type-definition.schema.json";
import { JSONSchemaType } from "./json-schema/schema-type";
import { JTDSchemaType } from "./json-type-definition/schema-type";

export const textCaseValues = [
  "PascalCase",
  "snake_case",
  "camelCase",
  "CONSTANT_CASE",
] as const;

export type TextCase = typeof textCaseValues[number];

export const recase = (str: string, type: TextCase): string => {
  if (!str) {
    return str;
  }

  switch (type) {
    case "PascalCase":
      return pascalCase(str).replace(/[a-zA-Z]_\d/g, (s) => s.replace("_", ""));
    case "camelCase":
      return camelCase(str);
    case "snake_case":
      return snakeCase(str);
    case "CONSTANT_CASE":
      return constantCase(str);
  }
};

export const zip = <T1, T2>(
  array1: Array<T1>,
  array2: Array<T2>
): Array<[T1, T2]> => {
  return array1.map((e, i) => [e, array2[i]]);
};

export const zipMapped = <T1, T2, O>(
  array1: Array<T1>,
  array2: Array<T2>,
  mapper: (elem1: T1, elem2: T2) => O
): Array<O> => {
  return array1.map((e, i) => mapper(e, array2[i]));
};

export { AjvJTDSchemaType };
const globalAjv = new Ajv({
  keywords: ["title"],
});
const globalJSONSchemaAjv = new AjvJSONSchema();

export interface SchemaValidator<T> {
  base: ValidateFunction<T>;
  schema: AjvJTDSchemaType<T>;
  validate: (value: unknown) => ValidateResult<T>;
}

type ValidateResult<T> =
  | { success: true; value: T }
  | {
      success: false;
      errors: Array<ErrorObject>;
      getErrorMessage: () => string;
    };

const jsonTypeDefSchema = JSONTypeDefSchema_ as unknown as AjvJSONSchemaType<
  JTDSchemaType<unknown>
>;

export const jsonTypeDefinitionValidator = {
  validate: globalJSONSchemaAjv.compile(jsonTypeDefSchema),
  getErrorMessage(): string {
    return globalJSONSchemaAjv.errorsText(this.validate.errors);
  },
};

export const jsonSchemaValidator = {
  validate: globalJSONSchemaAjv.schemas[
    "http://json-schema.org/draft-07/schema"
  ]!.validate as ValidateFunction<JSONSchemaType<unknown>>,
  getErrorMessage(): string {
    return globalJSONSchemaAjv.errorsText(this.validate.errors);
  },
};

export const compileCustomValidator = <T>(
  schema: AjvJTDSchemaType<T>
): SchemaValidator<T> => {
  const base = globalAjv.compile(schema);
  return {
    base,
    schema,
    validate: validateFunction(base, globalAjv),
  };
};

const validateFunction = <T>(
  base: ValidateFunction<T>,
  ajv: { errorsText: (errors: Array<ErrorObject>) => string }
) => {
  return (value: unknown): ValidateResult<T> => {
    const success = base(value);
    if (success) {
      return { success, value };
    }
    const errors = base.errors!;
    return {
      success,
      errors,
      getErrorMessage: () => ajv.errorsText(errors),
    };
  };
};

export const parseYamlOrJson = (doc: {
  text: string;
  uri: string;
}): unknown => {
  let data: unknown;
  if (doc.uri.match(/\.(yaml|yml)$/)) {
    data = yaml.parse(doc.text);
  } else {
    data = (JSON5 as { parse: (text: string) => unknown }).parse(doc.text);
  }
  return data;
};

export const printYamlOrJson = (doc: {
  document: Record<string, unknown>;
  uri: string;
}): string => {
  let data: string;
  if (doc.uri.match(/\.(yaml|yml)$/)) {
    data = yaml.stringify(doc.document);
  } else if (doc.uri.match(/\.(json5|jsonc)$/)) {
    data = JSON5.stringify(doc.document);
  } else {
    data = JSON.stringify(doc.document);
  }
  return data;
};

export const getOrSetMap = <K, V>(map: Map<K, V>, key: K, func: () => V): V => {
  if (map.has(key)) {
    return map.get(key) as V;
  }
  const value = func();
  map.set(key, value);
  return value;
};

1	import Ajv, {	1✔
2	ErrorObject,
3	JTDSchemaType as AjvJTDSchemaType,
4	ValidateFunction,
5	} from "ajv/dist/jtd";
6	import AjvJSONSchema, { JSONSchemaType as AjvJSONSchemaType } from "ajv";	1✔
7	import { camelCase, constantCase, pascalCase, snakeCase } from "change-case";	1✔
8	import * as yaml from "yaml";	1✔
9	import JSON5 from "json5";	1✔
10	import * as JSONTypeDefSchema_ from "./json-type-definition/json-type-definition.schema.json";	1✔
11	import { JSONSchemaType } from "./json-schema/schema-type";
12	import { JTDSchemaType } from "./json-type-definition/schema-type";
13
14	export const textCaseValues = [	1✔
15	"PascalCase",
16	"snake_case",
17	"camelCase",
18	"CONSTANT_CASE",
19	] as const;
20
21	export type TextCase = typeof textCaseValues[number];
22
23	export const recase = (str: string, type: TextCase): string => {	1✔
24	if (!str) {	159!
25	return str;	×
26	}
27
28	switch (type) {	159!
29	case "PascalCase":
30	return pascalCase(str).replace(/[a-zA-Z]_\d/g, (s) => s.replace("_", ""));	95✔
31	case "camelCase":
32	return camelCase(str);	35✔
33	case "snake_case":
34	return snakeCase(str);	29✔
35	case "CONSTANT_CASE":
36	return constantCase(str);	×
37	}
38	};
39
40	export const zip = <T1, T2>(	1✔
41	array1: Array<T1>,
42	array2: Array<T2>
43	): Array<[T1, T2]> => {
44	return array1.map((e, i) => [e, array2[i]]);	812✔
45	};
46
47	export const zipMapped = <T1, T2, O>(	1✔
48	array1: Array<T1>,
49	array2: Array<T2>,
50	mapper: (elem1: T1, elem2: T2) => O
51	): Array<O> => {
52	return array1.map((e, i) => mapper(e, array2[i]));	×
53	};
54
55	export { AjvJTDSchemaType };
56	const globalAjv = new Ajv({	1✔
57	keywords: ["title"],
58	});
59	const globalJSONSchemaAjv = new AjvJSONSchema();	1✔
60
61	export interface SchemaValidator<T> {
62	base: ValidateFunction<T>;
63	schema: AjvJTDSchemaType<T>;
64	validate: (value: unknown) => ValidateResult<T>;
65	}
66
67	type ValidateResult<T> =
68	\| { success: true; value: T }
69	\| {
70	success: false;
71	errors: Array<ErrorObject>;
72	getErrorMessage: () => string;
73	};
74
75	const jsonTypeDefSchema = JSONTypeDefSchema_ as unknown as AjvJSONSchemaType<	1✔
76	JTDSchemaType<unknown>
77	>;
78
79	export const jsonTypeDefinitionValidator = {	1✔
80	validate: globalJSONSchemaAjv.compile(jsonTypeDefSchema),
81	getErrorMessage(): string {
82	return globalJSONSchemaAjv.errorsText(this.validate.errors);	×
83	},
84	};
85
86	export const jsonSchemaValidator = {	1✔
87	validate: globalJSONSchemaAjv.schemas[
88	"http://json-schema.org/draft-07/schema"
89	]!.validate as ValidateFunction<JSONSchemaType<unknown>>,
90	getErrorMessage(): string {
91	return globalJSONSchemaAjv.errorsText(this.validate.errors);	×
92	},
93	};
94
95	export const compileCustomValidator = <T>(	1✔
96	schema: AjvJTDSchemaType<T>
97	): SchemaValidator<T> => {
98	const base = globalAjv.compile(schema);	3✔
99	return {	3✔
100	base,
101	schema,
102	validate: validateFunction(base, globalAjv),
103	};
104	};
105
106	const validateFunction = <T>(	1✔
107	base: ValidateFunction<T>,
108	ajv: { errorsText: (errors: Array<ErrorObject>) => string }
109	) => {
110	return (value: unknown): ValidateResult<T> => {	3✔
111	const success = base(value);	×
112	if (success) {	×
113	return { success, value };	×
114	}
115	const errors = base.errors!;	×
116	return {	×
117	success,
118	errors,
119	getErrorMessage: () => ajv.errorsText(errors),	×
120	};
121	};
122	};
123
124	export const parseYamlOrJson = (doc: {	1✔
125	text: string;
126	uri: string;
127	}): unknown => {
128	let data: unknown;
129	if (doc.uri.match(/\.(yaml\|yml)$/)) {	3!
130	data = yaml.parse(doc.text);	×
131	} else {
132	data = (JSON5 as { parse: (text: string) => unknown }).parse(doc.text);	3✔
133	}
134	return data;	3✔
135	};
136
137	export const printYamlOrJson = (doc: {	1✔
138	document: Record<string, unknown>;
139	uri: string;
140	}): string => {
141	let data: string;
142	if (doc.uri.match(/\.(yaml\|yml)$/)) {	×
143	data = yaml.stringify(doc.document);	×
144	} else if (doc.uri.match(/\.(json5\|jsonc)$/)) {	×
145	data = JSON5.stringify(doc.document);	×
146	} else {
147	data = JSON.stringify(doc.document);	×
148	}
149	return data;	×
150	};
151
152	export const getOrSetMap = <K, V>(map: Map<K, V>, key: K, func: () => V): V => {	1✔
153	if (map.has(key)) {	52✔
154	return map.get(key) as V;	42✔
155	}
156	const value = func();	10✔
157	map.set(key, value);	10✔
158	return value;	10✔
159	};

juancastillo0 / dart-fixer / 4190369997

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