Untie actions from tooltips

Author: lierdakil

dist/main.js

@@ -0,0 +1,52 @@
+import { TextEditor, Range, CompositeDisposable } from 'atom'
+import { PluginManager } from '../plugin-manager'
+import * as UPI from 'atom-haskell-upi'
+import TEventRangeType = UPI.TEventRangeType
+import { PriorityRegistry } from '../priority-registry'
+import { selectAction } from './select-action'
+
+export class ActionRegistry extends PriorityRegistry<UPI.Action[]> {
+  protected disposables = new CompositeDisposable()
+  constructor(private readonly pluginManager: PluginManager) {
+    super()
+    this.disposables.add(
+      atom.commands.add('atom-text-editor.ide-haskell', {
+        'ide-haskell:show-actions': async ({ currentTarget }) => {
+          const editor = currentTarget.getModel()
+          const act = await this.pluginManager.actionRegistry.getActions(
+            editor,
+            TEventRangeType.context,
+            editor.getSelectedBufferRange(),
+          )
+          if (act && act.length) {
+            const choice = await selectAction(act)
+            if (choice) await choice.apply()
+          }
+        },
+      }),
+    )
+  }
+
+  public dispose() {
+    super.dispose()
+    this.disposables.dispose()
+  }
+
+  public async getActions(
+    editor: TextEditor,
+    type: TEventRangeType,
+    crange: Range,
+  ) {
+    for (const { pluginName, handler, eventTypes } of this.providers) {
+      if (!eventTypes.includes(type)) {
+        continue
+      }
+      const awaiter = this.pluginManager.getAwaiter(pluginName)
+      const actions = await awaiter(() => handler(editor, crange, type))
+      if (actions === undefined) continue
+      if (!actions.length) continue
+      return actions
+    }
+    return undefined
+  }
+}

dist/main.js.map

@@ -13,15 +13,15 @@ import TEventRangeType = UPI.TEventRangeType
 import { ResultsDB, ResultItem } from '../results-db'
 import { PluginManager, IEditorController } from '../plugin-manager'
 import { listen, bufferPositionFromMouseEvent, handlePromise } from '../utils'
-import { TooltipRegistry } from '../tooltip-registry'
+import { TooltipManager } from '../tooltip-manager'
 
 export class CREditorControl implements IEditorController {
   private gutter: Gutter
   private gutterElement: HTMLElement
   private markers: DisplayMarkerLayer
   private disposables: CompositeDisposable
   private markerProps: WeakMap<DisplayMarker, ResultItem>
-  private tooltipRegistry: TooltipRegistry
+  private tooltipManager: TooltipManager
   private resultsDB: ResultsDB
   constructor(private editor: TextEditor, pluginManager: PluginManager) {
     const gutter = this.editor.gutterWithName('ide-haskell-check-results')
@@ -36,7 +36,7 @@ export class CREditorControl implements IEditorController {
     this.gutterElement = atom.views.getView(this.gutter)
 
     this.resultsDB = pluginManager.resultsDB
-    this.tooltipRegistry = pluginManager.tooltipRegistry
+    this.tooltipManager = pluginManager.tooltipManager
 
     this.disposables = new CompositeDisposable()
     this.markers = editor.addMarkerLayer({
@@ -87,19 +87,6 @@ export class CREditorControl implements IEditorController {
     }
   }
 
-  public async getActionAt(
-    pos: Point,
-    type: TEventRangeType | 'gutter',
-  ): Promise<UPI.Action[]> {
-    return ([] as UPI.Action[]).concat(
-      ...(await Promise.all(
-        Array.from(this.getResultAt(pos, type)).map((res) =>
-          res.actions ? res.actions() : [],
-        ),
-      )),
-    )
-  }
-
   private registerGutterEvents() {
     this.disposables.add(
       listen(this.gutterElement, 'mouseover', '.decoration', (e) => {
@@ -111,7 +98,7 @@ export class CREditorControl implements IEditorController {
           const msg = Array.from(this.getMessageAt(bufferPt, 'gutter'))
           if (msg.length > 0) {
             handlePromise(
-              this.tooltipRegistry.showTooltip(
+              this.tooltipManager.showTooltip(
                 this.editor,
                 TEventRangeType.mouse,
                 {
@@ -129,7 +116,7 @@ export class CREditorControl implements IEditorController {
     )
     this.disposables.add(
       listen(this.gutterElement, 'mouseout', '.decoration', () =>
-        this.tooltipRegistry.hideTooltip(
+        this.tooltipManager.hideTooltip(
           this.editor,
           TEventRangeType.mouse,
           'builtin:check-results',

src/actions-provider/index.ts

@@ -47,9 +47,8 @@ export class CheckResultsProvider {
       return undefined
     }
     const msg = Array.from(controller.getMessageAt(crange.start, type))
-    const actions = () => controller.getActionAt(crange.start, type)
     if (msg.length > 0) {
-      return { range: crange, text: msg, actions }
+      return { range: crange, text: msg }
     }
     return undefined
   }

src/actions-registry/index.ts

@@ -1,9 +1,7 @@
-import { TooltipMessage } from './tooltip-view'
 import { EventTable } from './event-table'
 import * as AtomTypes from 'atom'
 import * as UPI from 'atom-haskell-upi'
 import TEventRangeType = UPI.TEventRangeType
-import { MessageObject } from '../utils'
 
 type Range = AtomTypes.Range
 type TextEditor = AtomTypes.TextEditor
@@ -13,7 +11,7 @@ export interface IMarkerProperties extends AtomTypes.FindDisplayMarkerOptions {
   persistent: boolean
 }
 
-export class TooltipManager {
+export class EditorOverlayManager {
   private markers: EventTable
   private editorElement: HTMLElement
   constructor(private editor: TextEditor) {
@@ -31,18 +29,17 @@ export class TooltipManager {
 
   public show(
     range: Range,
-    text: MessageObject | MessageObject[],
-    actions: Promise<JSX.Element | undefined> | undefined,
     type: TEventRangeType,
     source: string,
     detail: IMarkerProperties,
+    view: object,
   ) {
     this.hide(type, source)
     const highlightMarker = this.markers
       .get(type, source)
       .markBufferRange(range)
     highlightMarker.setProperties(detail)
-    this.decorate(highlightMarker, new TooltipMessage(source, text, actions))
+    this.decorate(highlightMarker, view)
     this.editorElement.classList.add('ide-haskell--has-tooltips')
   }
 
@@ -83,7 +80,7 @@ export class TooltipManager {
     }
   }
 
-  private decorate(marker: DisplayMarker, tooltipView: TooltipMessage) {
+  private decorate(marker: DisplayMarker, tooltipView: object) {
     this.editor.decorateMarker(marker, {
       type: 'overlay',
       position: 'tail',

src/actions-provider/select-action.ts renamed to src/actions-registry/select-action.ts

@@ -1,7 +1,7 @@
 import { Range, TextEditor, Point, CompositeDisposable, Disposable } from 'atom'
 import { bufferPositionFromMouseEvent, listen, handlePromise } from '../utils'
-import { TooltipManager } from './tooltip-manager'
-import { TooltipRegistry } from '../tooltip-registry'
+import { EditorOverlayManager } from './editor-overlay-manager'
+import { TooltipManager as GlobalTooltipManager } from '../tooltip-manager'
 import { PluginManager, IEditorController } from '../plugin-manager'
 import * as UPI from 'atom-haskell-upi'
 import TEventRangeType = UPI.TEventRangeType
@@ -11,7 +11,7 @@ export type TEventRangeResult =
   | undefined
 
 export class EditorControl implements IEditorController {
-  public readonly tooltips: TooltipManager
+  public readonly tooltips: EditorOverlayManager
   private readonly disposables: CompositeDisposable
   private lastMouseBufferPt?: Point
   private exprTypeTimeout?: number
@@ -28,15 +28,15 @@ export class EditorControl implements IEditorController {
       height: number
     }
   }
-  private readonly tooltipRegistry: TooltipRegistry
+  private readonly tooltipManager: GlobalTooltipManager
   constructor(
     private readonly editor: TextEditor,
     pluginManager: PluginManager,
   ) {
     this.disposables = new CompositeDisposable()
-    this.tooltips = new TooltipManager(this.editor)
+    this.tooltips = new EditorOverlayManager(this.editor)
     this.disposables.add(this.tooltips)
-    this.tooltipRegistry = pluginManager.tooltipRegistry
+    this.tooltipManager = pluginManager.tooltipManager
 
     this.editorElement = atom.views.getView(this.editor) as any
 
@@ -130,7 +130,7 @@ export class EditorControl implements IEditorController {
     ) {
       this.tooltips.hide(type)
     } else {
-      handlePromise(this.tooltipRegistry.showTooltip(this.editor, type))
+      handlePromise(this.tooltipManager.showTooltip(this.editor, type))
     }
   }
 
@@ -177,7 +177,7 @@ export class EditorControl implements IEditorController {
       }
 
       handlePromise(
-        this.tooltipRegistry.showTooltip(this.editor, TEventRangeType.keyboard),
+        this.tooltipManager.showTooltip(this.editor, TEventRangeType.keyboard),
       )
       if (
         atom.config.get('ide-haskell.onCursorMove', {

src/check-results-provider/editor-control.ts

@@ -21,7 +21,8 @@ import * as UPI from 'atom-haskell-upi'
 import * as Linter from 'atom/linter'
 import * as StatusBar from 'atom/status-bar'
 import { handlePromise } from './utils'
-import { ActionsProvider } from './actions-provider'
+import { ActionRegistry } from './actions-registry'
+import { TooltipManager } from './tooltip-manager'
 
 export { IParamState, IOutputViewState }
 
@@ -55,6 +56,8 @@ export class PluginManager {
   public readonly resultsDB: ResultsDB
   public readonly configParamManager: ConfigParamManager
   public readonly tooltipRegistry: TooltipRegistry
+  public readonly actionRegistry: ActionRegistry
+  public readonly tooltipManager: TooltipManager
   private readonly checkResultsProvider?: CheckResultsProvider
   private linterSupport?: LinterSupport
   private readonly disposables = new CompositeDisposable()
@@ -73,16 +76,16 @@ export class PluginManager {
     ECMap<IEditorController>
   >()
   private readonly backendStatusController = new BackendStatusController()
-  private readonly actionsProvider: ActionsProvider
 
   constructor(state: IState, public outputPanel: OutputPanel) {
     this.disposables.add(this.emitter)
 
     this.resultsDB = new ResultsDB()
     this.outputPanel.connectResults(this.resultsDB)
     this.outputPanel.connectBsc(this.backendStatusController)
-    this.actionsProvider = new ActionsProvider(this)
-    this.tooltipRegistry = new TooltipRegistry(this, this.actionsProvider)
+    this.actionRegistry = new ActionRegistry(this)
+    this.tooltipRegistry = new TooltipRegistry(this)
+    this.tooltipManager = new TooltipManager(this)
     this.configParamManager = new ConfigParamManager(
       this.outputPanel,
       state.configParams,
@@ -93,7 +96,7 @@ export class PluginManager {
       this.addEditorController(PrettifyEditorController),
       this.addEditorController(EditorMarkControl),
       this.tooltipRegistry,
-      this.actionsProvider,
+      this.actionRegistry,
     )
     if (atom.config.get('ide-haskell.messageDisplayFrontend') === 'builtin') {
       this.checkResultsProvider = new CheckResultsProvider(this)

src/check-results-provider/index.ts

@@ -0,0 +1,54 @@
+import { TextEditor, Disposable, Range } from 'atom'
+import * as UPI from 'atom-haskell-upi'
+import TEventRangeType = UPI.TEventRangeType
+
+interface SpecDefinition<T> {
+  priority: number
+  eventTypes?: TEventRangeType[]
+  handler: (
+    editor: TextEditor,
+    crange: Range,
+    type: TEventRangeType,
+  ) => T | undefined | Promise<T | undefined>
+}
+
+export class PriorityRegistry<Spec> {
+  protected providers: Array<
+    SpecDefinition<Spec> & {
+      pluginName: string
+      eventTypes: TEventRangeType[]
+    }
+  > = []
+
+  public dispose() {
+    this.providers = []
+  }
+
+  public register(
+    pluginName: string,
+    provider: SpecDefinition<Spec>,
+  ): Disposable {
+    const idx = this.providers.findIndex(
+      ({ priority }) => priority < provider.priority,
+    )
+    const defaultEvT: TEventRangeType[] = [
+      TEventRangeType.selection,
+      TEventRangeType.mouse,
+    ]
+    const record = {
+      pluginName,
+      eventTypes: provider.eventTypes ? provider.eventTypes : defaultEvT,
+      priority: provider.priority,
+      handler: provider.handler,
+    }
+    if (idx === -1) {
+      this.providers.push(record)
+    } else {
+      this.providers.splice(idx, 0, record)
+    }
+    return new Disposable(() => {
+      const ix = this.providers.indexOf(record)
+      this.providers.splice(ix, 1)
+    })
+  }
+}