mirror of
https://github.com/ritz078/transform.git
synced 2026-11-22 17:11:32 +03:00
215 lines
5.6 KiB
JavaScript
215 lines
5.6 KiB
JavaScript
/*
|
|
JSON-to-Go
|
|
by Matt Holt
|
|
|
|
https://github.com/mholt/json-to-go
|
|
|
|
A simple utility to translate JSON into a Go type definition.
|
|
*/
|
|
|
|
function jsonToGo (json, typename) {
|
|
let data
|
|
let scope
|
|
let go = ''
|
|
let tabs = 0
|
|
|
|
try {
|
|
data = JSON.parse(json.replace(/\.0/g, '.1')) // hack that forces floats to stay as floats
|
|
scope = data
|
|
}
|
|
catch (e) {
|
|
return {
|
|
go: '',
|
|
error: e.message
|
|
}
|
|
}
|
|
|
|
typename = format(typename || 'AutoGenerated')
|
|
append('type ' + typename + ' ')
|
|
|
|
parseScope(scope)
|
|
|
|
return {go: go}
|
|
|
|
function parseScope (scope) {
|
|
let keyname
|
|
if (typeof scope === 'object' && scope !== null) {
|
|
if (Array.isArray(scope)) {
|
|
let i
|
|
let sliceType, scopeLength = scope.length
|
|
|
|
for (i = 0; i < scopeLength; i++) {
|
|
const thisType = goType(scope[i])
|
|
if (!sliceType)
|
|
sliceType = thisType
|
|
else if (sliceType !== thisType) {
|
|
sliceType = mostSpecificPossibleGoType(thisType, sliceType)
|
|
if (sliceType === 'interface{}')
|
|
break
|
|
}
|
|
}
|
|
|
|
append('[]')
|
|
if (sliceType === 'struct') {
|
|
let k
|
|
let keys
|
|
const allFields = {}
|
|
|
|
// for each field counts how many times appears
|
|
for (i = 0; i < scopeLength; i++) {
|
|
keys = Object.keys(scope[i])
|
|
for (k in keys) {
|
|
keyname = keys[k]
|
|
if (!(keyname in allFields)) {
|
|
allFields[keyname] = {
|
|
value: scope[i][keyname],
|
|
count: 0
|
|
}
|
|
}
|
|
|
|
allFields[keyname].count++
|
|
}
|
|
}
|
|
|
|
// create a common struct with all fields found in the current array
|
|
// omitempty dict indicates if a field is optional
|
|
keys = Object.keys(allFields)
|
|
let struct = {}, omitempty = {}
|
|
for (k in keys) {
|
|
keyname = keys[k]
|
|
let elem = allFields[keyname]
|
|
|
|
struct[keyname] = elem.value
|
|
omitempty[keyname] = elem.count !== scopeLength
|
|
}
|
|
|
|
parseStruct(struct, omitempty) // finally parse the struct !!
|
|
}
|
|
else if (sliceType === 'slice') {
|
|
parseScope(scope[0])
|
|
}
|
|
else
|
|
append(sliceType || 'interface{}')
|
|
}
|
|
else {
|
|
parseStruct(scope)
|
|
}
|
|
}
|
|
else
|
|
append(goType(scope))
|
|
}
|
|
|
|
function parseStruct (scope, omitempty) {
|
|
append('struct {\n')
|
|
++tabs
|
|
const keys = Object.keys(scope)
|
|
for (const i in keys) {
|
|
const keyname = keys[i]
|
|
indent(tabs)
|
|
append(format(keyname) + ' ')
|
|
parseScope(scope[keyname])
|
|
|
|
append(' `json:"' + keyname)
|
|
if (omitempty && omitempty[keyname] === true) {
|
|
append(',omitempty')
|
|
}
|
|
append('"`\n')
|
|
}
|
|
indent(--tabs)
|
|
append('}')
|
|
}
|
|
|
|
function indent (tabs) {
|
|
for (let i = 0; i < tabs; i++)
|
|
go += '\t';
|
|
}
|
|
|
|
function append (str) {
|
|
go += str
|
|
}
|
|
|
|
// Sanitizes and formats a string to make an appropriate identifier in Go
|
|
function format (str) {
|
|
if (!str)
|
|
return ''
|
|
else if (str.match(/^\d+$/))
|
|
str = 'Num' + str
|
|
else if (str.charAt(0).match(/\d/)) {
|
|
const numbers = {
|
|
'0': 'Zero_', '1': 'One_', '2': 'Two_', '3': 'Three_',
|
|
'4': 'Four_', '5': 'Five_', '6': 'Six_', '7': 'Seven_',
|
|
'8': 'Eight_', '9': 'Nine_'
|
|
}
|
|
str = numbers[str.charAt(0)] + str.substr(1)
|
|
}
|
|
return toProperCase(str).replace(/[^a-z0-9]/ig, '') || 'NAMING_FAILED'
|
|
}
|
|
|
|
// Determines the most appropriate Go type
|
|
function goType (val) {
|
|
if (val === null)
|
|
return 'interface{}'
|
|
|
|
switch (typeof val) {
|
|
case 'string':
|
|
if (/\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d(\.\d+)?(\+\d\d:\d\d|Z)/.test(val))
|
|
return 'time.Time'
|
|
else
|
|
return 'string'
|
|
case 'number':
|
|
if (val % 1 === 0) {
|
|
if (val > -2147483648 && val < 2147483647)
|
|
return 'int'
|
|
else
|
|
return 'int64'
|
|
}
|
|
else
|
|
return 'float64'
|
|
case 'boolean':
|
|
return 'bool'
|
|
case 'object':
|
|
if (Array.isArray(val))
|
|
return 'slice'
|
|
return 'struct'
|
|
default:
|
|
return 'interface{}'
|
|
}
|
|
}
|
|
|
|
// Given two types, returns the more specific of the two
|
|
function mostSpecificPossibleGoType (typ1, typ2) {
|
|
if (typ1.substr(0, 5) === 'float'
|
|
&& typ2.substr(0, 3) === 'int')
|
|
return typ1
|
|
else if (typ1.substr(0, 3) === 'int'
|
|
&& typ2.substr(0, 5) === 'float')
|
|
return typ1
|
|
else
|
|
return 'interface{}'
|
|
}
|
|
|
|
// Proper cases a string according to Go conventions
|
|
function toProperCase (str) {
|
|
// https://github.com/golang/lint/blob/39d15d55e9777df34cdffde4f406ab27fd2e60c0/lint.go#L695-L731
|
|
const commonInitialisms = [
|
|
'API', 'ASCII', 'CPU', 'CSS', 'DNS', 'EOF', 'GUID', 'HTML', 'HTTP',
|
|
'HTTPS', 'ID', 'IP', 'JSON', 'LHS', 'QPS', 'RAM', 'RHS', 'RPC', 'SLA',
|
|
'SMTP', 'SSH', 'TCP', 'TLS', 'TTL', 'UDP', 'UI', 'UID', 'UUID', 'URI',
|
|
'URL', 'UTF8', 'VM', 'XML', 'XSRF', 'XSS'
|
|
]
|
|
|
|
return str.replace(/(^|[^a-zA-Z])([a-z]+)/g, function (unused, sep, frag) {
|
|
if (commonInitialisms.indexOf(frag.toUpperCase()) >= 0)
|
|
return sep + frag.toUpperCase()
|
|
else
|
|
return sep + frag[0].toUpperCase() + frag.substr(1).toLowerCase()
|
|
}).replace(/([A-Z])([a-z]+)/g, function (unused, sep, frag) {
|
|
if (commonInitialisms.indexOf(sep + frag.toUpperCase()) >= 0)
|
|
return (sep + frag).toUpperCase()
|
|
else
|
|
return sep + frag
|
|
})
|
|
}
|
|
}
|
|
|
|
module.exports = jsonToGo |