LSP snippets

lib/editor-store.js

@@ -5,7 +5,6 @@ class EditorStore {
     this.editor = editor
     this.buffer = this.editor.getBuffer()
     this.observer = null
-    this.checkpoint = null
     this.expansions = []
     this.existingHistoryProvider = null
   }
@@ -52,14 +51,6 @@ class EditorStore {
     this.observer = null
     return true
   }
-
-  makeCheckpoint () {
-    const existing = this.checkpoint
-    if (existing) {
-      this.buffer.groupChangesSinceCheckpoint(existing)
-    }
-    this.checkpoint = this.buffer.createCheckpoint()
-  }
 }
 
 EditorStore.store = new WeakMap()

lib/helpers.js

@@ -1,8 +1,6 @@
-/** @babel */
+const path = require('path')
 
-import path from 'path'
-
-export function getPackageRoot() {
+function getPackageRoot() {
   const {resourcePath} = atom.getLoadSettings()
   const currentFileWasRequiredFromSnapshot = !path.isAbsolute(__dirname)
   if (currentFileWasRequiredFromSnapshot) {
@@ -11,3 +9,5 @@ export function getPackageRoot() {
     return path.resolve(__dirname, '..')
   }
 }
+
+module.exports = {getPackageRoot}

lib/insertion.js

@@ -1,93 +1,27 @@
-const ESCAPES = {
-  u: (flags) => {
-    flags.lowercaseNext = false
-    flags.uppercaseNext = true
-  },
-  l: (flags) => {
-    flags.uppercaseNext = false
-    flags.lowercaseNext = true
-  },
-  U: (flags) => {
-    flags.lowercaseAll = false
-    flags.uppercaseAll = true
-  },
-  L: (flags) => {
-    flags.uppercaseAll = false
-    flags.lowercaseAll = true
-  },
-  E: (flags) => {
-    flags.uppercaseAll = false
-    flags.lowercaseAll = false
-  },
-  r: (flags, result) => {
-    result.push('\\r')
-  },
-  n: (flags, result) => {
-    result.push('\\n')
-  },
-  $: (flags, result) => {
-    result.push('$')
-  }
-}
-
-function transformText (str, flags) {
-  if (flags.uppercaseAll) {
-    return str.toUpperCase()
-  } else if (flags.lowercaseAll) {
-    return str.toLowerCase()
-  } else if (flags.uppercaseNext) {
-    flags.uppercaseNext = false
-    return str.replace(/^./, s => s.toUpperCase())
-  } else if (flags.lowercaseNext) {
-    return str.replace(/^./, s => s.toLowerCase())
-  }
-  return str
-}
+const {transformWithSubstitution} = require('./util')
 
 class Insertion {
-  constructor ({ range, substitution }) {
+  constructor ({range, substitution, references, choices=[], transformResolver}) {
     this.range = range
     this.substitution = substitution
-    if (substitution) {
-      if (substitution.replace === undefined) {
-        substitution.replace = ''
-      }
-      this.replacer = this.makeReplacer(substitution.replace)
+    this.references = references
+    if (substitution && substitution.replace === undefined) {
+      substitution.replace = ''
     }
+    this.choices = choices
+    this.transformResolver = transformResolver
   }
 
   isTransformation () {
     return !!this.substitution
   }
 
-  makeReplacer (replace) {
-    return function replacer (...match) {
-      let flags = {
-        uppercaseAll: false,
-        lowercaseAll: false,
-        uppercaseNext: false,
-        lowercaseNext: false
-      }
-      replace = [...replace]
-      let result = []
-      replace.forEach(token => {
-        if (typeof token === 'string') {
-          result.push(transformText(token, flags))
-        } else if (token.escape) {
-          ESCAPES[token.escape](flags, result)
-        } else if (token.backreference) {
-          let transformed = transformText(match[token.backreference], flags)
-          result.push(transformed)
-        }
-      })
-      return result.join('')
-    }
+  isChoice () {
+    return this.choices.length > 0
   }
 
   transform (input) {
-    let { substitution } = this
-    if (!substitution) { return input }
-    return input.replace(substitution.find, this.replacer)
+    return transformWithSubstitution(input, this.substitution, this.transformResolver)
   }
 }
 

lib/resolvers.js

@@ -0,0 +1,223 @@
+const path = require('path')
+
+
+class ValueResolver {
+  constructor (resolvers = new Map) {
+    this.resolvers = resolvers
+  }
+
+  add (varName, resolver) {
+    this.resolvers.set(varName, resolver)
+  }
+
+  /*
+  Params depend on context. VariableResolver can expect the following, but TransformResolver will likely get a restricted number
+  (VariableResolver) params = {
+    variable: the variable name this was called with
+    editor: the TextEditor we are expanding in
+    cursor: the cursor we are expanding from
+    indent: the indent of the original cursor line. Automatically applied to all text (post variable transformation)
+    selectionRange: the original selection range of the cursor. This has been modified on the actual cursor to now select the prefix
+    startPosition: the cursor selection start position, after being adjusted to select the prefix
+    row: the row the start of the variable will be inserted on (final) <- final for snippet body creation. Does not account for changes when the user starts typing
+    column: the column the start of the variable will be inserted on (final; accounts for indent)
+  }
+
+  (TransformResolver) params = {
+    input: the text to be transformed
+    transform: the transform this was called with
+  }
+  */
+  resolve (name, params) {
+    const resolver = this.resolvers.get(name)
+    if (resolver) {
+      return {
+        hasResolver: true,
+        value: resolver(params)
+      }
+    }
+    return {
+      hasResolver: false,
+      value: undefined
+    }
+  }
+}
+
+class VariableResolver extends ValueResolver {
+  constructor (resolvers = new Map) {
+    super(new Map([
+      ['CLIPBOARD', resolveClipboard],
+
+      ['TM_SELECTED_TEXT', resolveSelected],
+      ['TM_CURRENT_LINE', resolveCurrentLine],
+      ['TM_CURRENT_WORD', resolveCurrentWord],
+      ['TM_LINE_INDEX', resolveLineIndex],
+      ['TM_LINE_NUMBER', resolveLineNumber],
+      ['TM_FILENAME', resolveFileName],
+      ['TM_FILENAME_BASE', resolveFileNameBase],
+      ['TM_DIRECTORY', resolveFileDirectory],
+      ['TM_FILEPATH', resolveFilePath],
+
+      ['CURRENT_YEAR', resolveYear],
+      ['CURRENT_YEAR_SHORT', resolveYearShort],
+      ['CURRENT_MONTH', resolveMonth],
+      ['CURRENT_MONTH_NAME', resolveMonthName],
+      ['CURRENT_MONTH_NAME_SHORT', resolveMonthNameShort],
+      ['CURRENT_DATE', resolveDate],
+      ['CURRENT_DAY_NAME', resolveDayName],
+      ['CURRENT_DAY_NAME_SHORT', resolveDayNameShort],
+      ['CURRENT_HOUR', resolveHour],
+      ['CURRENT_MINUTE', resolveMinute],
+      ['CURRENT_SECOND', resolveSecond],
+
+      ['BLOCK_COMMENT_START', resolveBlockCommentStart],
+      ['BLOCK_COMMENT_END', resolveBlockCommentEnd],
+      ['LINE_COMMENT', resolveLineComment],
+
+      ...resolvers
+    ]))
+  }
+}
+
+function resolveClipboard () {
+  return atom.clipboard.read()
+}
+
+function resolveSelected ({editor, selectionRange}) {
+  if (!selectionRange || selectionRange.isEmpty()) return undefined
+  return editor.getTextInBufferRange(selectionRange)
+}
+
+function resolveCurrentLine ({editor, cursor}) {
+  return editor.lineTextForBufferRow(cursor.getBufferRow())
+}
+
+function resolveCurrentWord ({editor, cursor}) {
+  return editor.getTextInBufferRange(cursor.getCurrentWordBufferRange())
+}
+
+function resolveLineIndex ({cursor}) {
+  return `${cursor.getBufferRow()}`
+}
+
+function resolveLineNumber ({cursor}) {
+  return `${cursor.getBufferRow() + 1}`
+}
+
+function resolveFileName ({editor}) {
+  return editor.getTitle()
+}
+
+function resolveFileNameBase ({editor}) {
+  const fileName = resolveFileName({editor})
+  if (!fileName) { return undefined }
+
+  const index = fileName.lastIndexOf('.')
+  if (index >= 0) {
+    return fileName.slice(0, index)
+  }
+
+  return fileName
+}
+
+function resolveFileDirectory ({editor}) {
+  const filePath = editor.getPath()
+  if (filePath === undefined) return undefined
+  return path.dirname(filePath)
+}
+
+function resolveFilePath ({editor}) {
+  return editor.getPath()
+}
+
+
+// TODO: Use correct locale
+function resolveYear () {
+  return new Date().toLocaleString('en-us', {year: 'numeric'})
+}
+
+function resolveYearShort () { // last two digits of year
+  return new Date().toLocaleString('en-us', {year: '2-digit'})
+}
+
+function resolveMonth () {
+  return new Date().toLocaleString('en-us', {month: '2-digit'})
+}
+
+function resolveMonthName () {
+  return new Date().toLocaleString('en-us', {month: 'long'})
+}
+
+function resolveMonthNameShort () {
+  return new Date().toLocaleString('en-us', {month: 'short'})
+}
+
+function resolveDate () {
+  return new Date().toLocaleString('en-us', {day: '2-digit'})
+}
+
+function resolveDayName () {
+  return new Date().toLocaleString('en-us', {weekday: 'long'})
+}
+
+function resolveDayNameShort () {
+  return new Date().toLocaleString('en-us', {weekday: 'short'})
+}
+
+function resolveHour () {
+  return new Date().toLocaleString('en-us', {hour12: false, hour: '2-digit'})
+}
+
+function resolveMinute () {
+  return new Date().toLocaleString('en-us', {minute: '2-digit'})
+}
+
+function resolveSecond () {
+  return new Date().toLocaleString('en-us', {second: '2-digit'})
+}
+
+// TODO: wait for https://github.com/atom/atom/issues/18812
+// Could make a start with what we have; one of the two should be available
+function getEditorCommentStringsForPoint (_editor, _point) {
+  return {line: '//', start: '/*', end: '*/'}
+}
+
+function resolveBlockCommentStart ({editor, cursor}) {
+  const delims = getEditorCommentStringsForPoint(editor, cursor.getBufferPosition())
+  return delims.start
+}
+
+function resolveBlockCommentEnd ({editor, cursor}) {
+  const delims = getEditorCommentStringsForPoint(editor, cursor.getBufferPosition())
+  return delims.end
+}
+
+function resolveLineComment ({editor, cursor}) {
+  const delims = getEditorCommentStringsForPoint(editor, cursor.getBufferPosition())
+  return delims.line
+}
+
+class TransformResolver extends ValueResolver {
+  constructor (resolvers = new Map) {
+    super(new Map([
+      ['upcase', transformUpcase],
+      ['downcase', transformDowncase],
+      ['capitalize', transformCapitalize],
+      ...resolvers
+    ]))
+  }
+}
+
+function transformUpcase ({input}) {
+  return input.toLocaleUpperCase()
+}
+
+function transformDowncase ({input}) {
+  return input.toLocaleLowerCase()
+}
+
+function transformCapitalize ({input}) {
+  return input ? input[0].toLocaleUpperCase() + input.substr(1) : ''
+}
+
+module.exports = { ValueResolver, VariableResolver, TransformResolver }