ByoungSooPark/modeling-app
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fix indentation for wrapped array and object expressions, within pipe bodies (#77)

Browse Source
This commit is contained in:
Kurt Hutten
2023-03-20 08:13:21 +11:00
committed by GitHub
parent 37ebfd072c
commit 5f7ee2c512
4 changed files with 115 additions and 76 deletions
Download Patch File Download Diff File Expand all files Collapse all files

28
src/lang/recast.test.ts
View File

@ -303,6 +303,34 @@ describe('testing call Expressions in BinaryExpressions and UnaryExpressions', (
}) })
}) })
describe('it recasts wrapped object expressions in pipe bodies with correct indentation', () => {
it('with a single line', () => {
const code = `const part001 = startSketchAt([-0.01, -0.08])
|> line({ to: [0.62, 4.15], tag: 'seg01' }, %)
|> line([2.77, -1.24], %)
|> angledLineThatIntersects({
angle: 201,
offset: -1.35,
intersectTag: 'seg01'
}, %)
|> line([-0.42, -1.72], %)
show(part001)`
const { ast } = code2ast(code)
const recasted = recast(ast)
expect(recasted).toBe(code)
})
it('recasts wrapped object expressions NOT in pipe body correctly', () => {
const code = `angledLineThatIntersects({
angle: 201,
offset: -1.35,
intersectTag: 'seg01'
}, %)`
const { ast } = code2ast(code)
const recasted = recast(ast)
expect(recasted).toBe(code)
})
})
// helpers // helpers
function code2ast(code: string): { ast: Program; tokens: Token[] } { function code2ast(code: string): { ast: Program; tokens: Token[] } {

31
src/lang/recast.ts
View File

@ -118,7 +118,8 @@ ${indentation}]`
function recastObjectExpression( function recastObjectExpression(
expression: ObjectExpression, expression: ObjectExpression,
indentation = '' indentation = '',
isInPipeExpression = false
): string { ): string {
const flatRecast = `{ ${expression.properties const flatRecast = `{ ${expression.properties
.map((prop) => `${prop.key.name}: ${recastValue(prop.value)}`) .map((prop) => `${prop.key.name}: ${recastValue(prop.value)}`)
@ -130,7 +131,7 @@ function recastObjectExpression(
${_indentation}${expression.properties ${_indentation}${expression.properties
.map((prop) => `${prop.key.name}: ${recastValue(prop.value)}`) .map((prop) => `${prop.key.name}: ${recastValue(prop.value)}`)
.join(`,\n${_indentation}`)} .join(`,\n${_indentation}`)}
}` ${isInPipeExpression ? ' ' : ''}}`
} }
return flatRecast return flatRecast
} }
@ -159,14 +160,19 @@ function recastLiteral(literal: Literal): string {
function recastCallExpression( function recastCallExpression(
expression: CallExpression, expression: CallExpression,
indentation = '' indentation = '',
isInPipeExpression = false
): string { ): string {
return `${expression.callee.name}(${expression.arguments return `${expression.callee.name}(${expression.arguments
.map((arg) => recastArgument(arg, indentation)) .map((arg) => recastArgument(arg, indentation, isInPipeExpression))
.join(', ')})` .join(', ')})`
} }
function recastArgument(argument: Value, indentation = ''): string { function recastArgument(
argument: Value,
indentation = '',
isInPipeExpression = false
): string {
if (argument.type === 'Literal') { if (argument.type === 'Literal') {
return recastLiteral(argument) return recastLiteral(argument)
} else if (argument.type === 'Identifier') { } else if (argument.type === 'Identifier') {
@ -176,7 +182,7 @@ function recastArgument(argument: Value, indentation = ''): string {
} else if (argument.type === 'ArrayExpression') { } else if (argument.type === 'ArrayExpression') {
return recastArrayExpression(argument, indentation) return recastArrayExpression(argument, indentation)
} else if (argument.type === 'ObjectExpression') { } else if (argument.type === 'ObjectExpression') {
return recastObjectExpression(argument) return recastObjectExpression(argument, indentation, isInPipeExpression)
} else if (argument.type === 'CallExpression') { } else if (argument.type === 'CallExpression') {
return recastCallExpression(argument) return recastCallExpression(argument)
} else if (argument.type === 'FunctionExpression') { } else if (argument.type === 'FunctionExpression') {
@ -212,13 +218,18 @@ function recastMemberExpression(
return expression.object.name + keyString return expression.object.name + keyString
} }
function recastValue(node: Value, indentation = ''): string { function recastValue(
node: Value,
_indentation = '',
isInPipeExpression = false
): string {
const indentation = _indentation + (isInPipeExpression ? ' ' : '')
if (node.type === 'BinaryExpression') { if (node.type === 'BinaryExpression') {
return recastBinaryExpression(node) return recastBinaryExpression(node)
} else if (node.type === 'ArrayExpression') { } else if (node.type === 'ArrayExpression') {
return recastArrayExpression(node, indentation) return recastArrayExpression(node, indentation)
} else if (node.type === 'ObjectExpression') { } else if (node.type === 'ObjectExpression') {
return recastObjectExpression(node, indentation) return recastObjectExpression(node, indentation, isInPipeExpression)
} else if (node.type === 'MemberExpression') { } else if (node.type === 'MemberExpression') {
return recastMemberExpression(node, indentation) return recastMemberExpression(node, indentation)
} else if (node.type === 'Literal') { } else if (node.type === 'Literal') {
@ -226,7 +237,7 @@ function recastValue(node: Value, indentation = ''): string {
} else if (node.type === 'FunctionExpression') { } else if (node.type === 'FunctionExpression') {
return recastFunction(node) return recastFunction(node)
} else if (node.type === 'CallExpression') { } else if (node.type === 'CallExpression') {
return recastCallExpression(node, indentation) return recastCallExpression(node, indentation, isInPipeExpression)
} else if (node.type === 'Identifier') { } else if (node.type === 'Identifier') {
return node.name return node.name
} else if (node.type === 'PipeExpression') { } else if (node.type === 'PipeExpression') {
@ -243,7 +254,7 @@ function recastPipeExpression(expression: PipeExpression): string {
let str = '' let str = ''
let indentation = ' ' let indentation = ' '
let maybeLineBreak = '\n' let maybeLineBreak = '\n'
str = recastValue(statement, indentation) str = recastValue(statement, indentation, true)
if ( if (
expression.nonCodeMeta?.[index]?.value && expression.nonCodeMeta?.[index]?.value &&
expression.nonCodeMeta?.[index].value !== ' ' expression.nonCodeMeta?.[index].value !== ' '

48
src/lang/std/sketchConstraints.test.ts
View File

@ -52,20 +52,20 @@ describe('testing swaping out sketch calls with xLine/xLineTo', () => {
` |> lineTo({ to: [1, 1], tag: 'abc1' }, %)`, ` |> lineTo({ to: [1, 1], tag: 'abc1' }, %)`,
` |> line({ to: [-2.04, -0.7], tag: 'abc2' }, %)`, ` |> line({ to: [-2.04, -0.7], tag: 'abc2' }, %)`,
` |> angledLine({`, ` |> angledLine({`,
` angle: 157,`, ` angle: 157,`,
` length: 1.69,`, ` length: 1.69,`,
` tag: 'abc3'`, ` tag: 'abc3'`,
`}, %)`, ` }, %)`,
` |> angledLineOfXLength({`, ` |> angledLineOfXLength({`,
` angle: 217,`, ` angle: 217,`,
` length: 0.86,`, ` length: 0.86,`,
` tag: 'abc4'`, ` tag: 'abc4'`,
`}, %)`, ` }, %)`,
` |> angledLineOfYLength({`, ` |> angledLineOfYLength({`,
` angle: 104,`, ` angle: 104,`,
` length: 1.58,`, ` length: 1.58,`,
` tag: 'abc5'`, ` tag: 'abc5'`,
`}, %)`, ` }, %)`,
` |> angledLineToX({ angle: 55, to: -2.89, tag: 'abc6' }, %)`, ` |> angledLineToX({ angle: 55, to: -2.89, tag: 'abc6' }, %)`,
` |> angledLineToY({ angle: 330, to: 2.53, tag: 'abc7' }, %)`, ` |> angledLineToY({ angle: 330, to: 2.53, tag: 'abc7' }, %)`,
` |> xLine({ length: 1.47, tag: 'abc8' }, %)`, ` |> xLine({ length: 1.47, tag: 'abc8' }, %)`,
@ -137,10 +137,10 @@ describe('testing swaping out sketch calls with xLine/xLineTo', () => {
inputCode: bigExample, inputCode: bigExample,
callToSwap: [ callToSwap: [
`angledLine({`, `angledLine({`,
` angle: 157,`, ` angle: 157,`,
` length: 1.69,`, ` length: 1.69,`,
` tag: 'abc3'`, ` tag: 'abc3'`,
`}, %)`, ` }, %)`,
].join('\n'), ].join('\n'),
constraintType: 'horizontal', constraintType: 'horizontal',
}) })
@ -165,10 +165,10 @@ describe('testing swaping out sketch calls with xLine/xLineTo', () => {
inputCode: bigExample, inputCode: bigExample,
callToSwap: [ callToSwap: [
`angledLineOfXLength({`, `angledLineOfXLength({`,
` angle: 217,`, ` angle: 217,`,
` length: 0.86,`, ` length: 0.86,`,
` tag: 'abc4'`, ` tag: 'abc4'`,
`}, %)`, ` }, %)`,
].join('\n'), ].join('\n'),
constraintType: 'horizontal', constraintType: 'horizontal',
}) })
@ -194,10 +194,10 @@ describe('testing swaping out sketch calls with xLine/xLineTo', () => {
inputCode: bigExample, inputCode: bigExample,
callToSwap: [ callToSwap: [
`angledLineOfYLength({`, `angledLineOfYLength({`,
` angle: 104,`, ` angle: 104,`,
` length: 1.58,`, ` length: 1.58,`,
` tag: 'abc5'`, ` tag: 'abc5'`,
`}, %)`, ` }, %)`,
].join('\n'), ].join('\n'),
constraintType: 'vertical', constraintType: 'vertical',
}) })

84
src/lang/std/sketchcombos.test.ts
View File

@ -124,64 +124,64 @@ const myAng2 = 134
const part001 = startSketchAt([0, 0]) const part001 = startSketchAt([0, 0])
|> line({ to: [1, 3.82], tag: 'seg01' }, %) // ln-should-get-tag |> line({ to: [1, 3.82], tag: 'seg01' }, %) // ln-should-get-tag
|> angledLineToX([ |> angledLineToX([
-angleToMatchLengthX('seg01', myVar, %), -angleToMatchLengthX('seg01', myVar, %),
myVar myVar
], %) // ln-lineTo-xAbsolute should use angleToMatchLengthX helper ], %) // ln-lineTo-xAbsolute should use angleToMatchLengthX helper
|> angledLineToY([ |> angledLineToY([
-angleToMatchLengthY('seg01', myVar, %), -angleToMatchLengthY('seg01', myVar, %),
myVar myVar
], %) // ln-lineTo-yAbsolute should use angleToMatchLengthY helper ], %) // ln-lineTo-yAbsolute should use angleToMatchLengthY helper
|> angledLine([45, segLen('seg01', %)], %) // ln-lineTo-free should become angledLine |> angledLine([45, segLen('seg01', %)], %) // ln-lineTo-free should become angledLine
|> angledLine([45, segLen('seg01', %)], %) // ln-angledLineToX-free should become angledLine |> angledLine([45, segLen('seg01', %)], %) // ln-angledLineToX-free should become angledLine
|> angledLine([myAng, segLen('seg01', %)], %) // ln-angledLineToX-angle should become angledLine |> angledLine([myAng, segLen('seg01', %)], %) // ln-angledLineToX-angle should become angledLine
|> angledLineToX([ |> angledLineToX([
angleToMatchLengthX('seg01', myVar2, %), angleToMatchLengthX('seg01', myVar2, %),
myVar2 myVar2
], %) // ln-angledLineToX-xAbsolute should use angleToMatchLengthX to get angle ], %) // ln-angledLineToX-xAbsolute should use angleToMatchLengthX to get angle
|> angledLine([315, segLen('seg01', %)], %) // ln-angledLineToY-free should become angledLine |> angledLine([315, segLen('seg01', %)], %) // ln-angledLineToY-free should become angledLine
|> angledLine([myAng2, segLen('seg01', %)], %) // ln-angledLineToY-angle should become angledLine |> angledLine([myAng2, segLen('seg01', %)], %) // ln-angledLineToY-angle should become angledLine
|> angledLineToY([ |> angledLineToY([
angleToMatchLengthY('seg01', myVar3, %), angleToMatchLengthY('seg01', myVar3, %),
myVar3 myVar3
], %) // ln-angledLineToY-yAbsolute should use angleToMatchLengthY to get angle ], %) // ln-angledLineToY-yAbsolute should use angleToMatchLengthY to get angle
|> line([ |> line([
min(segLen('seg01', %), myVar), min(segLen('seg01', %), myVar),
legLen(segLen('seg01', %), myVar) legLen(segLen('seg01', %), myVar)
], %) // ln-should use legLen for y ], %) // ln-should use legLen for y
|> line([ |> line([
min(segLen('seg01', %), myVar), min(segLen('seg01', %), myVar),
-legLen(segLen('seg01', %), myVar) -legLen(segLen('seg01', %), myVar)
], %) // ln-legLen but negative ], %) // ln-legLen but negative
|> angledLine([248, segLen('seg01', %)], %) // ln-should become angledLine |> angledLine([248, segLen('seg01', %)], %) // ln-should become angledLine
|> angledLine([myVar, segLen('seg01', %)], %) // ln-use segLen for secound arg |> angledLine([myVar, segLen('seg01', %)], %) // ln-use segLen for secound arg
|> angledLine([45, segLen('seg01', %)], %) // ln-segLen again |> angledLine([45, segLen('seg01', %)], %) // ln-segLen again
|> angledLine([54, segLen('seg01', %)], %) // ln-should be transformed to angledLine |> angledLine([54, segLen('seg01', %)], %) // ln-should be transformed to angledLine
|> angledLineOfXLength([ |> angledLineOfXLength([
legAngX(segLen('seg01', %), myVar), legAngX(segLen('seg01', %), myVar),
min(segLen('seg01', %), myVar) min(segLen('seg01', %), myVar)
], %) // ln-should use legAngX to calculate angle ], %) // ln-should use legAngX to calculate angle
|> angledLineOfXLength([ |> angledLineOfXLength([
180 + legAngX(segLen('seg01', %), myVar), 180 + legAngX(segLen('seg01', %), myVar),
min(segLen('seg01', %), myVar) min(segLen('seg01', %), myVar)
], %) // ln-same as above but should have + 180 to match original quadrant ], %) // ln-same as above but should have + 180 to match original quadrant
|> line([ |> line([
legLen(segLen('seg01', %), myVar), legLen(segLen('seg01', %), myVar),
min(segLen('seg01', %), myVar) min(segLen('seg01', %), myVar)
], %) // ln-legLen again but yRelative ], %) // ln-legLen again but yRelative
|> line([ |> line([
-legLen(segLen('seg01', %), myVar), -legLen(segLen('seg01', %), myVar),
min(segLen('seg01', %), myVar) min(segLen('seg01', %), myVar)
], %) // ln-negative legLen yRelative ], %) // ln-negative legLen yRelative
|> angledLine([58, segLen('seg01', %)], %) // ln-angledLineOfYLength-free should become angledLine |> angledLine([58, segLen('seg01', %)], %) // ln-angledLineOfYLength-free should become angledLine
|> angledLine([myAng, segLen('seg01', %)], %) // ln-angledLineOfYLength-angle should become angledLine |> angledLine([myAng, segLen('seg01', %)], %) // ln-angledLineOfYLength-angle should become angledLine
|> angledLineOfXLength([ |> angledLineOfXLength([
legAngY(segLen('seg01', %), myVar), legAngY(segLen('seg01', %), myVar),
min(segLen('seg01', %), myVar) min(segLen('seg01', %), myVar)
], %) // ln-angledLineOfYLength-yRelative use legAngY ], %) // ln-angledLineOfYLength-yRelative use legAngY
|> angledLineOfXLength([ |> angledLineOfXLength([
270 + legAngY(segLen('seg01', %), myVar), 270 + legAngY(segLen('seg01', %), myVar),
min(segLen('seg01', %), myVar) min(segLen('seg01', %), myVar)
], %) // ln-angledLineOfYLength-yRelative with angle > 90 use binExp ], %) // ln-angledLineOfYLength-yRelative with angle > 90 use binExp
|> xLine(segLen('seg01', %), %) // ln-xLine-free should sub in segLen |> xLine(segLen('seg01', %), %) // ln-xLine-free should sub in segLen
|> yLine(segLen('seg01', %), %) // ln-yLine-free should sub in segLen |> yLine(segLen('seg01', %), %) // ln-yLine-free should sub in segLen
|> xLine(segLen('seg01', %), %) // ln-xLineTo-free should convert to xLine |> xLine(segLen('seg01', %), %) // ln-xLineTo-free should convert to xLine
@ -380,9 +380,9 @@ show(part001)`
'setVertDistance' 'setVertDistance'
) )
expect(expectedCode).toContain(`|> lineTo([ expect(expectedCode).toContain(`|> lineTo([
lastSegX(%) + myVar, lastSegX(%) + myVar,
segEndY('seg01', %) + 2.93 segEndY('seg01', %) + 2.93
], %) // xRelative`) ], %) // xRelative`)
}) })
it('testing for yRelative to horizontal distance', () => { it('testing for yRelative to horizontal distance', () => {
const expectedCode = helperThing( const expectedCode = helperThing(
@ -391,9 +391,9 @@ show(part001)`
'setHorzDistance' 'setHorzDistance'
) )
expect(expectedCode).toContain(`|> lineTo([ expect(expectedCode).toContain(`|> lineTo([
segEndX('seg01', %) + 2.6, segEndX('seg01', %) + 2.6,
lastSegY(%) + myVar lastSegY(%) + myVar
], %) // yRelative`) ], %) // yRelative`)
}) })
}) })
}) })