LSP snippets

lib/snippet-body.pegjs

@@ -1,82 +1,141 @@
 {
-  // Joins all consecutive strings in a collection without clobbering any
-  // non-string members.
-  function coalesce (parts) {
-    const result = [];
-    for (let i = 0; i < parts.length; i++) {
-      const part = parts[i];
-      const ri = result.length - 1;
-      if (typeof part === 'string' && typeof result[ri] === 'string') {
-        result[ri] = result[ri] + part;
-      } else {
-        result.push(part);
-      }
-    }
-    return result;
-  }
-
-  function flatten (parts) {
-    return parts.reduce(function (flat, rest) {
-      return flat.concat(Array.isArray(rest) ? flatten(rest) : rest);
-    }, []);
+  function makeInteger(i) {
+    return parseInt(i.join(""), 10);
   }
 }
-bodyContent = content:(tabStop / bodyContentText)* { return content; }
-bodyContentText = text:bodyContentChar+ { return text.join(''); }
-bodyContentChar = escaped / !tabStop char:. { return char; }
 
-escaped = '\\' char:. { return char; }
-tabStop =  tabStopWithTransformation /  tabStopWithPlaceholder / tabStopWithoutPlaceholder / simpleTabStop
+bodyContent = content:(tabstop / choice / variable / text)* { return content; }
+
+innerBodyContent = content:(tabstop / choice / variable / nonCloseBraceText)* { return content; }
 
-simpleTabStop = '$' index:[0-9]+ {
-  return { index: parseInt(index.join("")), content: [] };
+tabstop = simpleTabstop / tabstopWithoutPlaceholder / tabstopWithPlaceholder / tabstopWithTransform
+
+simpleTabstop = '$' index:int {
+  return { index: makeInteger(index), content: [] }
 }
-tabStopWithoutPlaceholder = '${' index:[0-9]+ '}' {
-  return { index: parseInt(index.join("")), content: [] };
+
+tabstopWithoutPlaceholder = '${' index:int '}' {
+  return { index: makeInteger(index), content: [] }
 }
-tabStopWithPlaceholder = '${' index:[0-9]+ ':' content:placeholderContent '}' {
-  return { index: parseInt(index.join("")), content: content };
+
+tabstopWithPlaceholder = '${' index:int ':' content:innerBodyContent '}' {
+  return { index: makeInteger(index), content: content }
 }
-tabStopWithTransformation = '${' index:[0-9]+ substitution:transformationSubstitution '}' {
+
+tabstopWithTransform = '${' index:int substitution:transform '}' {
   return {
-    index: parseInt(index.join(""), 10),
+    index: makeInteger(index),
     content: [],
     substitution: substitution
-  };
+  }
 }
 
-placeholderContent = content:(tabStop / placeholderContentText / variable )* { return flatten(content); }
-placeholderContentText = text:placeholderContentChar+ { return coalesce(text); }
-placeholderContentChar = escaped / placeholderVariableReference / !tabStop !variable char:[^}] { return char; }
+choice = '${' index:int '|' choice:choicecontents '|}' {
+  return { index: makeInteger(index), choice: choice }
+}
 
-placeholderVariableReference = '$' digit:[0-9]+ {
-  return { index: parseInt(digit.join(""), 10), content: [] };
+choicecontents = elem:choicetext rest:(',' val:choicetext { return val } )* {
+  return [elem, ...rest]
 }
 
-variable = '${' variableContent '}' {
-  return ''; // we eat variables and do nothing with them for now
+choicetext = choicetext:(choiceEscaped / [^|,] / barred:('|' &[^}]) { return barred.join('') } )+ {
+  return choicetext.join('')
 }
-variableContent = content:(variable / variableContentText)* { return content; }
-variableContentText = text:variableContentChar+ { return text.join(''); }
-variableContentChar = !variable char:('\\}' / [^}]) { return char; }
 
-escapedForwardSlash = pair:'\\/' { return pair; }
+// Transform is applied when tabbed off
+transform = '/' regex:regexString '/' replace:replace '/' flags:flags {
+  return { find: new RegExp(regex, flags), replace: replace }
+}
 
-// A pattern and replacement for a transformed tab stop.
-transformationSubstitution = '/' find:(escapedForwardSlash / [^/])* '/' replace:formatString* '/' flags:[imy]* {
-  let reFind = new RegExp(find.join(''), flags.join('') + 'g');
-  return { find: reFind, replace: replace[0] };
+regexString = regex:(escaped / [^/])* {
+  return regex.join('')
 }
 
-formatString = content:(formatStringEscape / formatStringReference / escapedForwardSlash / [^/])+ {
-  return content;
+replace = (format / replacetext)*
+
+// TODO: Support conditionals
+format = simpleFormat / formatWithoutPlaceholder / formatWithCaseTransform / formatEscape
+
+simpleFormat = '$' index:int {
+  return { backreference: makeInteger(index) }
 }
-// Backreferencing a substitution. Different from a tab stop.
-formatStringReference = '$' digits:[0-9]+ {
-  return { backreference: parseInt(digits.join(''), 10) };
-};
-// One of the special control flags in a format string for case folding and
-// other tasks.
-formatStringEscape = '\\' flag:[ULulErn$] {
-  return { escape: flag };
+
+formatWithoutPlaceholder = '${' index:int '}' {
+  return { backreference: makeInteger(index) }
+}
+
+formatWithCaseTransform = '${' index:int ':' casetransform:casetransform '}' {
+  return { backreference: makeInteger(index), transform: casetransform }
+}
+
+formatEscape = '\\' flag:[ULulErn$] {
+  return { escape: flag }
+}
+
+casetransform = '/' type:[a-zA-Z]* {
+  return type.join('')
+}
+
+replacetext = replacetext:(!formatEscape escaped / !format char:[^/] { return char })+ {
+  return replacetext.join('')
+}
+
+variable = simpleVariable / variableWithoutPlaceholder / variableWithPlaceholder / variableWithTransform
+
+simpleVariable = '$' name:variableName {
+  return { variable: name }
+}
+
+variableWithoutPlaceholder = '${' name:variableName '}' {
+  return { variable: name  }
+}
+
+variableWithPlaceholder = '${' name:variableName ':' content:innerBodyContent '}' {
+    return { variable: name, content: content }
+}
+
+variableWithTransform = '${' name:variableName substitution:transform '}' {
+  return { variable: name, substitution: substitution }
+}
+
+variableName = first:[a-zA-Z_] rest:[a-zA-Z_0-9]* {
+  return first + rest.join('')
+}
+
+int = [0-9]+
+
+escaped = '\\' char:. {
+  switch (char) {
+    case '$':
+    case '\\':
+    case '\x7D': // back brace; PEGjs would treat it as the JS scope end though
+      return char
+    default:
+      return '\\' + char
+  }
+}
+
+choiceEscaped = '\\' char:. {
+  switch (char) {
+    case '$':
+    case '\\':
+    case '\x7D':
+    case '|':
+    case ',':
+      return char
+    default:
+      return '\\' + char
+  }
+}
+
+flags = flags:[a-z]* {
+  return flags.join('')
+}
+
+text = text:(escaped / !tabstop !tabstopWithPlaceholder !variable !choice  char:. { return char })+ {
+  return text.join('')
+}
+
+nonCloseBraceText = text:(escaped / !tabstop !tabstopWithPlaceholder !variable !choice char:[^}] { return char })+ {
+    return text.join('')
 }

lib/snippet-expansion.js

@@ -1,7 +1,7 @@
 const {CompositeDisposable, Range, Point} = require('atom')
 
 module.exports = class SnippetExpansion {
-  constructor(snippet, editor, cursor, snippets) {
+  constructor(snippet, editor, cursor, oldSelectionRange, snippets) {
     this.settingTabStop = false
     this.isIgnoringBufferChanges = false
     this.onUndoOrRedo = this.onUndoOrRedo.bind(this)
@@ -14,22 +14,27 @@ module.exports = class SnippetExpansion {
     this.selections = [this.cursor.selection]
 
     const startPosition = this.cursor.selection.getBufferRange().start
-    let {body, tabStopList} = this.snippet
-    let tabStops = tabStopList.toArray()
+    let {body, tabStopList} = this.snippet.toString({ editor: this.editor, cursor: this.cursor, selectionRange: oldSelectionRange })
+
+    this.tabStopList = tabStopList
+
+    let tabStops = this.tabStopList.toArray()
 
     let indent = this.editor.lineTextForBufferRow(startPosition.row).match(/^\s*/)[0]
     if (this.snippet.lineCount > 1 && indent) {
       // Add proper leading indentation to the snippet
       body = body.replace(/\n/g, `\n${indent}`)
 
+      // TODO: Remove concept of "body"; build on the fly each time to resolve variables and their transformations
+
       tabStops = tabStops.map(tabStop => tabStop.copyWithIndent(indent))
     }
 
     this.editor.transact(() => {
       this.ignoringBufferChanges(() => {
         this.editor.transact(() => {
           const newRange = this.cursor.selection.insertText(body, {autoIndent: false})
-          if (this.snippet.tabStopList.length > 0) {
+          if (this.tabStopList.length > 0) {
             this.subscriptions.add(this.cursor.onDidChangePosition(event => this.cursorMoved(event)))
             this.subscriptions.add(this.cursor.onDidDestroy(() => this.cursorDestroyed()))
             this.placeTabStopMarkers(startPosition, tabStops)
@@ -103,6 +108,9 @@ module.exports = class SnippetExpansion {
         if (!insertion.isTransformation()) { continue }
 
         var outputText = insertion.transform(inputText)
+
+        console.log(`Transformed ${inputText} to ${outputText}`)
+
         this.editor.transact(() => this.editor.setTextInBufferRange(range, outputText))
         const newRange = new Range(
           range.start,
@@ -152,7 +160,7 @@ module.exports = class SnippetExpansion {
     } else {
       // The user has tabbed past the last tab stop. If the last tab stop is a
       // $0, we shouldn't move the cursor any further.
-      if (this.snippet.tabStopList.hasEndStop) {
+      if (this.tabStopList.hasEndStop) {
         this.destroy()
         return false
       } else {

lib/snippet.js

@@ -2,55 +2,121 @@ const {Range} = require('atom')
 const TabStopList = require('./tab-stop-list')
 
 module.exports = class Snippet {
-  constructor({name, prefix, bodyText, description, descriptionMoreURL, rightLabelHTML, leftLabel, leftLabelHTML, bodyTree}) {
+  constructor({name, prefix, description, descriptionMoreURL, rightLabelHTML, leftLabel, leftLabelHTML, bodyTree, bodyText, variableResolver}) {
     this.name = name
     this.prefix = prefix
-    this.bodyText = bodyText
     this.description = description
     this.descriptionMoreURL = descriptionMoreURL
     this.rightLabelHTML = rightLabelHTML
     this.leftLabel = leftLabel
     this.leftLabelHTML = leftLabelHTML
-    this.tabStopList = new TabStopList(this)
-    this.body = this.extractTabStops(bodyTree)
+    this.bodyTree = bodyTree
+    this.bodyText = bodyText
+    this.variableResolver = variableResolver
   }
 
-  extractTabStops (bodyTree) {
+  toString (params) {
+    const tabStopList = new TabStopList(this)
     const bodyText = []
     let row = 0
     let column = 0
 
     // recursive helper function; mutates vars above
     let extractTabStops = bodyTree => {
-      for (const segment of bodyTree) {
+      for (let segment of bodyTree) {
         if (segment.index != null) {
           let {index, content, substitution} = segment
           if (index === 0) { index = Infinity; }
           const start = [row, column]
           extractTabStops(content)
           const range = new Range(start, [row, column])
-          const tabStop = this.tabStopList.findOrCreate({
+          const tabStop = tabStopList.findOrCreate({
             index,
             snippet: this
           })
           tabStop.addInsertion({ range, substitution })
-        } else if (typeof segment === 'string') {
-          bodyText.push(segment)
-          var segmentLines = segment.split('\n')
-          column += segmentLines.shift().length
-          let nextLine
-          while ((nextLine = segmentLines.shift()) != null) {
-            row += 1
-            column = nextLine.length
+        } else {
+          if (segment.variable !== undefined) {
+            let value = this.variableResolver.resolve({ name: segment.variable, ...params })
+            if (value === undefined) {
+              if (segment.content) {
+                extractTabStops(segment.content)
+              }
+            } else {
+              if (segment.substitution) {
+                try {
+                  value = applyVariableTransformation(value, segment.substitution)
+                } catch (e) {
+                  atom.notifications.addError(`Failed to transform snippet variable $${segment.variable}`, { detail: e })
+                }
+              }
+              segment = value
+            }
+          }
+
+          if (typeof segment === 'string') {
+            bodyText.push(segment)
+            var segmentLines = segment.split('\n')
+            column += segmentLines.shift().length
+            let nextLine
+            while ((nextLine = segmentLines.shift()) != null) {
+              row += 1
+              column = nextLine.length
+            }
           }
         }
       }
     }
 
-    extractTabStops(bodyTree)
+    extractTabStops(this.bodyTree)
     this.lineCount = row + 1
-    this.insertions = this.tabStopList.getInsertions()
+    this.insertions = tabStopList.getInsertions()
 
-    return bodyText.join('')
+    return { body: bodyText.join(''), tabStopList }
   }
 }
+
+function applyVariableTransformation (value, substitution) {
+  // TODO: Better bounds and type checking so errors aren't as cryptic
+
+  const replace = substitution.replace
+  const result = value.replace(substitution.find, (...match) => {
+    let interimResult = ''
+    for (let i = 0; i < replace.length; i++) {
+      if (typeof replace[i] === "string") {
+        interimResult += replace[i]
+        continue
+      }
+
+      const format = replace[i]
+
+      const index = format.backreference
+      if (index >= match.length - 2) { throw new Error ("Index too high") }
+
+      let capture = match[index]
+      if (capture === undefined) { continue }
+
+      if (format.transform) {
+        // TODO: Support custom transforms as well?
+        switch (format.transform) {
+          case 'upcase':
+            capture = capture.toLocaleUpperCase()
+            break
+          case 'downcase':
+            capture = capture.toLocaleLowerCase()
+            break
+          case 'capitalize':
+            capture = capture ? capture[0].toLocaleUpperCase() + capture.substr(1) : ''
+            break
+          default: {}
+        }
+      }
+
+      interimResult += capture
+    }
+
+    return interimResult
+  })
+
+  return result
+}