more tests

Author: Aerijo

lib/snippet-body.pegjs

@@ -35,7 +35,7 @@ Parse issues (such as unclosed tab stops or invalid regexes) are simply treated
 as plain text.
 
 NOTE: PEG.js is not designed for efficiency. With appropriate benchmarks, it should
-be a significant gain to hand write a parser.
+be a significant gain to hand write a parser (and remove the PEG.js dependency).
 
 */
 
@@ -55,11 +55,11 @@ be a significant gain to hand write a parser.
   }
 }
 
-// Grab anything that isn't \ or $, then try to build a special node out of it, and (at the top level) if that fails then just accept it as text
-topLevelContent = content:(text / escapedTopLevel / tabStop / choice / variable / any)* { return coalesce(content); }
+// Grab anything that isn't \ or $, then try to build a special node out of it, and (at the top level) if that fails then just accept the first character as text and continue
+topLevelContent = c:(text / escapedTopLevel / tabStop / choice / variable / .)* { return coalesce(c); }
 
-// Placeholder content. The same as top level, except we need to fail on '}' so that it can end the tab stop (the `any` rule would eat it if we used it here)
-tabStopContent = content:(tabStopText / escapedTabStop / tabStop / choice / variable / notCloseBrace)* { return coalesce(content); }
+// Placeholder content. The same as top level, except we need to fail on '}' so that it can end the tab stop (the any matcher would eat it if we used it here)
+tabStopContent = c:(tabStopText / escapedTabStop / tabStop / choice / variable / [^}])* { return coalesce(c); }
 
 // The forms of a tab stop. They all start with '$', so we pull that out here.
 tabStop = '$' t:(tabStopSimple / tabStopWithoutPlaceholder / tabStopWithPlaceholder / tabStopWithTransform) { return t; }
@@ -97,7 +97,7 @@ regexString = r:([^/\\] / '\\' c:. { return '\\' + c } )* { return r.join(""); }
 
 // The form of a substitution for a transformation. It is a mix of plain text + modifiers + backreferences to the find capture groups
 // It cannot access tab stop values.
-replace = (replaceText / format / replaceModifier / escapedReplace)*
+replace = r:(replaceText / format / replaceModifier / escapedReplace / [^}/])* { return coalesce(r); }
 
 // A reference to a capture group of the find regex of a transformation. Can conditionally
 // resolve based on if the match occurred, and have arbitrary modifiers applied to it.
@@ -126,28 +126,29 @@ formatWithIfElse = '{' n:integer ':?' ifContent:replace ':' elseContent:replace
 formatWithElse = '{' n:integer ':' '-'? elseContent:replace { return { backreference: n, elseContent }; }
 
 // Used in `format`s to transform a string using a JS function
-modifier = '/' modifier:var { return modifier; }
+modifier = '/' modifier:name { return modifier; }
 
 // Regex flags. Validation is performed when the regex itself is also known.
 flags = f:[a-z]* { return f.join(""); }
 
 // A tab stop that offers a choice between several fixed values. These values are plain text only.
 // This feature is not implemented, but the syntax is parsed to reserve it for future use.
 // It will currently just default to a regular tab stop with the first value as it's placeholder.
-choice = '${' n:integer '|' a:choiceText b:(',' c:choiceText { return c; } )* '|}' { return { index: n, choices: [a, ...b] }; }
+// Empty choices are still parsed, as we may wish to assign meaning to it in future.
+choice = '${' n:integer '|' c:(a:choiceText b:(',' c:choiceText { return c; } )* { return [a, ...b] })? '|}' { return { index: n, choices: c || [] }; }
 
 // Syntactically looks like a named tab stop. Variables are resolved in JS and may be
 // further processed with a transformation. Unrecognised variables are transformed into
 // tab stops with the variable name as a placeholder.
 variable = '$' v:(variableSimple / variablePlain / variableWithPlaceholder / variableWithTransform) { return v; }
 
-variableSimple = v:var { return { variable: v }; }
+variableSimple = v:name { return { variable: v }; }
 
-variablePlain = '{' v:var '}' { return { variable: v }; }
+variablePlain = '{' v:name '}' { return { variable: v }; }
 
-variableWithPlaceholder = '{' v:var ':' content:tabStopContent '}' { return { variable: v, content }; }
+variableWithPlaceholder = '{' v:name ':' content:tabStopContent '}' { return { variable: v, content }; }
 
-variableWithTransform = '{' v:var t:transformation '}' { return { variable: v, transformation: t }; }
+variableWithTransform = '{' v:name t:transformation '}' { return { variable: v, transformation: t }; }
 
 // Top level text. Anything that cannot be the start of something special. False negatives are handled later by the `any` rule
 text = t:([^$\\}])+ { return t.join("") }
@@ -174,16 +175,10 @@ escapedChoice = '\\' c:[$\\,|] { return c; }
 escapedReplace = '\\' c:[$\\/] { return c; }
 
 // We handle 'modifiers' separately to escapes. These indicate a change in state when building the replacement (e.g., capitalisation)
-replaceModifier = '\\' m:[uUlLeEnr] { return { modifier: m }; }
+replaceModifier = '\\' m:[ElLuUnr] { return { modifier: m }; }
 
 // Match nonnegative integers like those used for tab stop ordering
 integer = digits:[0-9]+ { return parseInt(digits.join(""), 10); }
 
 // Match variable names like TM_SELECTED_TEXT
-var = a:[a-zA-Z_] b:[a-zA-Z_0-9]* { return a + b.join(""); }
-
-// Match any single character. Useful to resolve any parse errors where something that looked like it would be special had malformed syntax.
-any = a:. { return a; }
-
-// Match anything that isn't a '}'. Useful for parse errors inside placeholder text, as `}` should be used to end the tab stop region
-notCloseBrace = a:[^}] { return a; }
+name = a:[a-zA-Z_] b:[a-zA-Z_0-9]* { return a + b.join(""); }