almost done now

i made some refactoring and such
this is more of a "hey, this is till being worked on" commit
stuff still to do:
- transformations are not done, i changed the format (easy)
- tests are incomplete (being worked on, not on this commit) (easy but time consuming)
- need to go over things and document them properly (hard, but i think i might have something to make it easier)

Author: fluvf

available-snippets-view.js

@@ -6,19 +6,18 @@ module.exports = class AvailableSnippetsView extends SelectListView {
       items: Object.entries(snippets.snippetsByScopes()
         .getPropertyValue(editor.getRootScopeDescriptor().getScopeChain())),
       filterKeyForItem: ([name, { prefix }]) => prefix + name,
-      elementForItem: ([name, { prefix }]) => {
+      elementForItem: ([name, { prefix, description }]) => {
         const li = document.createElement('li')
         li.classList.add('two-lines')
 
-        const primaryLine = document.createElement('div')
+        const primaryLine = li.appendChild(document.createElement('div'))
         primaryLine.classList.add('primary-line')
         primaryLine.textContent = prefix
-        li.appendChild(primaryLine)
 
-        const secondaryLine = document.createElement('div')
+        const secondaryLine = li.appendChild(document.createElement('div'))
         secondaryLine.classList.add('secondary-line')
-        secondaryLine.textContent = name
-        li.appendChild(secondaryLine)
+        // TODO: Nullish coalescing operator
+        secondaryLine.textContent = description != null ? description : name
 
         return li
       },

constructs/tabstop.js

@@ -0,0 +1,60 @@
+const { CompositeDisposable } = require('atom')
+
+const Expression = require('./expression')
+
+module.exports = class Choice extends Expression {
+  constructor (identifier, choices) {
+    super(identifier)
+
+    this.choices = choices
+    // The "first" and therefore default values is last in the list so that
+    // choice cycling starts from the second choice
+    this.default = choices[choices.length - 1]
+  }
+
+  activate (editor, cursor, stop, mirror) {
+    super.activate(editor, cursor, stop, mirror)
+    // Don't bother if a mirror, the marker won't get iterated over
+    if (mirror === stop) {
+      const disposables = new CompositeDisposable()
+
+      const target = 'atom-text-editor:not([mini])'
+      const cycle = `snippets:next-choice-${stop.id}`
+
+      const choices = {
+        choices: this.choices,
+        iterator: this.choices.values(),
+        next () {
+          const iteration = this.iterator.next()
+          const { value } = iteration.done
+            ? (this.iterator = this.choices.values()).next()
+            : iteration
+          editor.getBuffer().setTextInRange(stop.getBufferRange(), value)
+          cursor.selection.setBufferRange(stop.getBufferRange())
+        }
+      }
+
+      // What happens when the user clicks inside the choice, resulting in it nolonger being selected
+      disposables.add(
+        atom.keymaps.add(module.filename, { [target]: { 'shift-tab': cycle } }),
+        atom.commands.add(target, cycle, event => choices.next()),
+        cursor.onDidChangePosition(({ newBufferPosition }) => {
+          if (!stop.getBufferRange().containsPoint(newBufferPosition)) {
+            disposables.dispose()
+          }
+        }))
+    }
+  }
+
+  expand (editor, cursor, tabstops, variables) {
+    if (!(this.identifier in variables)) {
+      this.mark({ tabstops, ...this.insert(editor, cursor, this.default) })
+    } else {
+      super.expand(editor, cursor, tabstops, variables)
+    }
+  }
+
+  toString () {
+    return this.default.toString()
+  }
+}

constructs/variable.js

@@ -1,9 +1,20 @@
-module.exports = class Construct {
+module.exports = class Expression {
   constructor (identifier) {
     this.identifier = identifier
   }
 
-  expand () {}
+  expand (editor, cursor, tabstops, variables) {
+    // Check whether we are a tabstop or a variable
+    Number.isInteger(this.identifier)
+      // Create a tabstop marker at our position
+      ? this.mark({ tabstops, start: cursor.getBufferPosition() })
+      // Check whether we are a know variable or not
+      : this.identifier in variables
+        // Insert the variables value
+        ? this.insert(editor, cursor, variables[this.identifier])
+        // Insert 'this.identifier' and create a tabstop marker with it selected
+        : this.mark({ tabstops, ...this.insert(editor, cursor, this.identifier) })
+  }
 
   insert (editor, cursor, value) {
     return editor.getBuffer().insert(cursor.getBufferPosition(), value)
@@ -24,8 +35,8 @@ module.exports = class Construct {
     }
   }
 
-  mark ({ tabstops, start, end = start, exclusive = true, construct = this }) {
-    tabstops.markBufferRange({ start, end }, { exclusive }).setProperties({ construct })
+  mark ({ tabstops, start, end = start, exclusive = true, expression = this }) {
+    tabstops.markBufferRange({ start, end }, { exclusive }).setProperties({ expression })
   }
 
   toString () {

constructs/babel.config.json expression/babel.config.json

@@ -0,0 +1,21 @@
+const Expression = require('./expression')
+
+module.exports = class Placeholder extends Expression {
+  constructor (identifier, snippet) {
+    super(identifier)
+
+    this.snippet = snippet
+  }
+
+  expand (editor, cursor, tabstops, variables) {
+    if (!(this.identifier in variables)) {
+      this.mark({ tabstops, ...this.snippet.expand({ editor, cursor, tabstops, variables }) })
+    } else {
+      super.expand(editor, cursor, tabstops, variables)
+    }
+  }
+
+  toString () {
+    return this.snippet.toString()
+  }
+}

expression/choice.js

@@ -1,9 +1,9 @@
 const { CompositeDisposable } = require('atom')
 const path = require('path')
 
-const Construct = require('./construct')
+const Expression = require('./expression')
 
-module.exports = class Snippet extends Construct {
+module.exports = class Snippet extends Expression {
   static VARIABLES = {
     // The currently selected text or the empty string
     TM_SELECTED_TEXT: (editor, cursor) => cursor.selection.getText(),
@@ -61,9 +61,10 @@ module.exports = class Snippet extends Construct {
     // LINE_COMMENT
     //
     // custom = custom variables
+    // TODO: I dont remember what this cache is supposed to do
     PROXY: (editor, cursor, custom) => new Proxy({}, {
       get: (cache, property) => property in this.VARIABLES
-        ? (cache[property] = this.VARIABLES[property]())
+        ? (cache[property] = this.VARIABLES[property](editor, cursor))
         : property in custom
           ? custom[property]
           // We should never see this value used
@@ -77,12 +78,12 @@ module.exports = class Snippet extends Construct {
     const unknowns = []
 
     markers.forEach(marker => {
-      const { construct } = marker.getProperties()
+      const { expression } = marker.getProperties()
 
-      Number.isInteger(construct.identifier)
-        ? Array.isArray(tabstops[construct.identifier])
-            ? tabstops[construct.identifier].push(marker)
-            : tabstops[construct.identifier] = [marker]
+      Number.isInteger(expression.identifier)
+        ? Array.isArray(tabstops[expression.identifier])
+            ? tabstops[expression.identifier].push(marker)
+            : tabstops[expression.identifier] = [marker]
         : unknowns.push([marker])
     })
     // Include all unknown variables at the end
@@ -95,21 +96,18 @@ module.exports = class Snippet extends Construct {
     return tabstops
   }
 
-  constructor (body, legacySyntax) {
+  constructor (body) {
     // This snippet will work as the default ending tabstop
     super(0)
 
     this.body = body
-
-    this.legacySyntax = legacySyntax
   }
 
   // We work as the default ending tabstop, this is a special case
   activate (editor, cursor, stop, mirror) {
     cursor.setBufferPosition(stop.getBufferRange().end)
   }
 
-  // helper cause Snippet isn't really ever available
   expand ({
     editor = atom.workspace.getActiveTextEditor(),
     cursor = editor.getLastCursor(),
@@ -123,7 +121,7 @@ module.exports = class Snippet extends Construct {
       })
     }
 
-    // Construct a variable proxy to access given and built-in variables
+    // Expression a variable proxy to access given and built-in variables
     variables = Snippet.VARIABLES.PROXY(editor, cursor, variables)
 
     // Define a marker that spans the whole snippet
@@ -160,8 +158,8 @@ module.exports = class Snippet extends Construct {
           const iteration = this.iterator.next()
           if (!iteration.done) {
             const { value: [stop] } = iteration
-            const { construct } = stop.getProperties()
-            iteration.value.forEach(mirror => construct.activate(editor, cursor, stop, mirror))
+            const { expression } = stop.getProperties()
+            iteration.value.forEach(mirror => expression.activate(editor, cursor, stop, mirror))
             return true
           }
           disposables.dispose()

constructs/construct.js expression/expression.js

@@ -0,0 +1,40 @@
+const Expression = require('./expression')
+
+module.exports = class Transformation extends Expression {
+  constructor (identifier, [regexp, format, flags]) {
+    super(identifier)
+
+    this.regexp = new RegExp(regexp, flags.join(''))
+    this.format = format
+  }
+
+  activate (editor, cursor, stop, mirror) {
+    super.activate(editor, cursor, stop, mirror)
+    mirror.onDidDestroy(() => {
+      const range = mirror.getBufferRange()
+      const buffer = editor.getBuffer()
+      buffer.setTextInRange(range, this.transform(buffer.getTextInRange(range)))
+    })
+  }
+
+  transform (string, regexp = this.regexp) {
+    let fold = sequence => sequence
+    return this.format.reduce((result, sequence) => {
+      const [group, insertion, replacement = ''] = sequence
+      sequence instanceof Function
+        ? fold = sequence
+        : sequence instanceof Object
+          ? result += fold(string.replace(regexp, group) ? insertion : replacement)
+          : result += fold(string.replace(regexp, sequence))
+      return result
+    }, '')
+  }
+
+  insert (editor, cursor, value) {
+    return super.insert(editor, cursor, this.transform(value))
+  }
+
+  toString () {
+    return this.transform(super.toString())
+  }
+}