misc/blocks type definitions

Author: aminya

lib_src/misc/blocks.ts

@@ -1,59 +1,70 @@
-'use babel'
 // TODO: docstrings
+// TODO: replace getHeadBufferPosition with getBufferRowRange? - getHeadBufferPosition isn't public API
+// TODO: make sure returned range from getRanges is not undefined
 
 import { forLines } from './scopes'
+import { TextEditor, Selection } from "atom"
 
-export function getLine (ed, l) {
+interface LineInfo {
+  scope: readonly string[]
+  line: string
+}
+
+export function getLine (editor: TextEditor, l: number): LineInfo {
   return {
-    scope: ed.scopeDescriptorForBufferPosition([l, 0]).scopes,
-    line: ed.getTextInBufferRange([[l, 0], [l, Infinity]])
+    scope: editor.scopeDescriptorForBufferPosition([l, 0]).getScopesArray(), // was .scopes
+    line: editor.getTextInBufferRange([[l, 0], [l, Infinity]])
   }
 }
 
-function isBlank ({line, scope}, allowDocstrings = false) {
+function isBlank ({line, scope}: LineInfo, allowDocstrings = false) {
   for (const s of scope) {
     if (/\bcomment\b/.test(s) || (!allowDocstrings && /\bdocstring\b/.test(s))) {
       return true
     }
   }
   return /^\s*(#.*)?$/.test(line);
 }
-function isEnd ({ line, scope }) {
-  if (isStringEnd({ line, scope })) {
+
+function isEnd (lineInfo: LineInfo) {
+  if (isStringEnd(lineInfo)) {
     return true
   }
-  return /^(end\b|\)|\]|\})/.test(line);
+  return /^(end\b|\)|\]|\})/.test(lineInfo.line);
 }
-function isStringEnd ({ line, scope }) {
-  scope = scope.join(' ')
+
+function isStringEnd (lineInfo: LineInfo) {
+  const scope = lineInfo.scope.join(' ')
   return /\bstring\.multiline\.end\b/.test(scope) ||
         (/\bstring\.end\b/.test(scope) && /\bbacktick\b/.test(scope));
 }
-function isCont ({ line, scope }) {
-  scope = scope.join(' ')
+
+function isCont (lineInfo: LineInfo) {
+  const scope = lineInfo.scope.join(' ')
   if (/\bstring\b/.test(scope) && !(/\bpunctuation\.definition\.string\b/.test(scope))) {
     return true
   }
 
-  return line.match(/^(else|elseif|catch|finally)\b/);
+  return lineInfo.line.match(/^(else|elseif|catch|finally)\b/);
 }
-function isStart (lineInfo) {
+
+function isStart (lineInfo: LineInfo) {
   return !(/^\s/.test(lineInfo.line) || isBlank(lineInfo) || isEnd(lineInfo) || isCont(lineInfo));
 }
 
-function walkBack(ed, row) {
-  while ((row > 0) && !isStart(getLine(ed, row))) {
+function walkBack(editor :TextEditor, row: number) {
+  while ((row > 0) && !isStart(getLine(editor, row))) {
     row--
   }
   return row
 }
 
-function walkForward (ed, start) {
+function walkForward (editor: TextEditor, start: number) {
   let end = start
   let mark = start
-  while (mark < ed.getLastBufferRow()) {
+  while (mark < editor.getLastBufferRow()) {
     mark++
-    const lineInfo = getLine(ed, mark)
+    const lineInfo = getLine(editor, mark)
 
     if (isStart(lineInfo)) {
       break
@@ -63,7 +74,7 @@ function walkForward (ed, start) {
       // returning a non-empty array).
       // If the line closes a multiline string we also take that as ending the block.
       if (
-            !(forLines(ed, start, mark-1).length === 0) ||
+            !(forLines(editor, start, mark-1).length === 0) ||
             isStringEnd(lineInfo)
          ) {
         end = mark
@@ -75,74 +86,76 @@ function walkForward (ed, start) {
   return end
 }
 
-function getRange (ed, row) {
-  const start = walkBack(ed, row)
-  const end = walkForward(ed, start)
+function getRange (editor: TextEditor, row: number): [[number, number], [number, number]] | undefined {
+  const start = walkBack(editor, row)
+  const end = walkForward(editor, start)
   if (start <= row && row <= end) {
     return [[start, 0], [end, Infinity]]
+  } else {
+    return undefined // TODO
   }
 }
 
-function getSelection (ed, sel) {
-  const {start, end} = sel.getBufferRange()
+function getSelection (editor: TextEditor, selection: Selection) {
+  const {start, end} = selection.getBufferRange()
   const range = [[start.row, start.column], [end.row, end.column]]
-  while (isBlank(getLine(ed, range[0][0]), true) && (range[0][0] <= range[1][0])) {
+  while (isBlank(getLine(editor, range[0][0]), true) && (range[0][0] <= range[1][0])) {
     range[0][0]++
     range[0][1] = 0
   }
-  while (isBlank(getLine(ed, range[1][0]), true) && (range[1][0] >= range[0][0])) {
+  while (isBlank(getLine(editor, range[1][0]), true) && (range[1][0] >= range[0][0])) {
     range[1][0]--
     range[1][1] = Infinity
   }
   return range
 }
 
-export function moveNext (ed, sel, range) {
+export function moveNext (editor: TextEditor, selection: Selection, range: [[number, number], [number, number]]) {
   // Ensure enough room at the end of the buffer
   const row = range[1][0]
   let last
-  while ((last = ed.getLastBufferRow()) < (row+2)) {
-    if ((last !== row) && !isBlank(getLine(ed, last))) {
+  while ((last = editor.getLastBufferRow()) < (row+2)) {
+    if ((last !== row) && !isBlank(getLine(editor, last))) {
       break
     }
-    sel.setBufferRange([[last, Infinity], [last, Infinity]])
-    sel.insertText('\n')
+    selection.setBufferRange([[last, Infinity], [last, Infinity]])
+    selection.insertText('\n')
   }
   // Move the cursor
   let to = row + 1
-  while ((to < ed.getLastBufferRow()) && isBlank(getLine(ed, to))) {
+  while ((to < editor.getLastBufferRow()) && isBlank(getLine(editor, to))) {
     to++
   }
-  to = walkForward(ed, to)
-  return sel.setBufferRange([[to, Infinity], [to, Infinity]])
+  to = walkForward(editor, to)
+  return selection.setBufferRange([[to, Infinity], [to, Infinity]])
 }
 
-function getRanges (ed) {
-  const ranges = ed.getSelections().map(sel => {
+function getRanges (editor: TextEditor) {
+  const ranges = editor.getSelections().map(selection => {
     return {
-      selection: sel,
-      range: sel.isEmpty() ?
-        getRange(ed, sel.getHeadBufferPosition().row) :
-        getSelection(ed, sel)
+      selection: selection,
+      range: selection.isEmpty() ?
+        getRange(editor, selection.getHeadBufferPosition().row) :
+        getSelection(editor, selection)
     }
   })
   return ranges.filter(({ range }) => {
-    return range && ed.getTextInBufferRange(range).trim()
+    return range && editor.getTextInBufferRange(range).trim()
   })
 }
 
-export function get (ed) {
-  return getRanges(ed).map(({ range, selection }) => {
+export function get (editor: TextEditor) {
+  return getRanges(editor).map(({ range, selection }) => {
     return {
       range,
       selection,
       line: range[0][0],
-      text: ed.getTextInBufferRange(range)
+      text: editor.getTextInBufferRange(range)
     }
   })
 }
 
-export function getLocalContext (editor, row) {
+export function getLocalContext (editor: TextEditor, row: number) {
   const range = getRange(editor, row)
   const context = range ? editor.getTextInBufferRange(range) : ''
   // NOTE:
@@ -156,10 +169,10 @@ export function getLocalContext (editor, row) {
   }
 }
 
-export function select (ed = atom.workspace.getActiveTextEditor()) {
-  if (!ed) return
-  return ed.mutateSelectedText(selection => {
-    const range = getRange(ed, selection.getHeadBufferPosition().row)
+export function select (editor = atom.workspace.getActiveTextEditor()) {
+  if (!editor) return
+  return editor.mutateSelectedText(selection => {
+    const range = getRange(editor, selection.getHeadBufferPosition().row)
     if (range) {
       selection.setBufferRange(range)
     }