refactor: rename fetch{Hover,Actions} -> get{Hover,Actions}

"get" is better than "fetch" because these no longer necessarily come from a remote source.

BREAKING CHANGE: Fields were renamed: fetch{Hover,Actions} -> get{Hover,Actions}.

Author: sqs

src/hoverifier.test.ts

@@ -17,7 +17,7 @@ import {
 } from './hoverifier'
 import { findPositionsFromEvents, SupportedMouseEvent } from './positions'
 import { CodeViewProps, DOM } from './testutils/dom'
-import { createHoverAttachment, createStubActionsFetcher, createStubHoverFetcher } from './testutils/fixtures'
+import { createHoverAttachment, createStubActionsProvider, createStubHoverProvider } from './testutils/fixtures'
 import { dispatchMouseEventAtPositionImpure } from './testutils/mouse'
 import { HoverAttachment, LOADING } from './types'
 
@@ -43,8 +43,8 @@ describe('Hoverifier', () => {
                     closeButtonClicks: NEVER,
                     hoverOverlayElements: of(null),
                     hoverOverlayRerenders: EMPTY,
-                    fetchHover: createStubHoverFetcher({ range: hoverRange }, LOADER_DELAY + delayTime),
-                    fetchActions: () => of(null),
+                    getHover: createStubHoverProvider({ range: hoverRange }, LOADER_DELAY + delayTime),
+                    getActions: () => of(null),
                 })
 
                 const positionJumps = new Subject<PositionJump>()
@@ -104,8 +104,8 @@ describe('Hoverifier', () => {
                     closeButtonClicks: NEVER,
                     hoverOverlayElements: of(null),
                     hoverOverlayRerenders: EMPTY,
-                    fetchHover: createStubHoverFetcher(hover, delayTime),
-                    fetchActions: createStubActionsFetcher(['foo', 'bar'], delayTime),
+                    getHover: createStubHoverProvider(hover, delayTime),
+                    getActions: createStubActionsProvider(['foo', 'bar'], delayTime),
                 })
 
                 const positionJumps = new Subject<PositionJump>()
@@ -193,11 +193,11 @@ describe('Hoverifier', () => {
                         hoverOverlayElements: of(null),
                         hoverOverlayRerenders: EMPTY,
                         // Only show on line 24, not line 25 (which is the 2nd click event below).
-                        fetchHover: position =>
-                            position.line === 24 ? createStubHoverFetcher({}, delayTime)(position) : of(null),
-                        fetchActions: position =>
+                        getHover: position =>
+                            position.line === 24 ? createStubHoverProvider({}, delayTime)(position) : of(null),
+                        getActions: position =>
                             position.line === 24
-                                ? createStubActionsFetcher(['foo', 'bar'], delayTime)(position)
+                                ? createStubActionsProvider(['foo', 'bar'], delayTime)(position)
                                 : of(null),
                     })
 
@@ -265,10 +265,9 @@ describe('Hoverifier', () => {
                         hoverOverlayElements: of(null),
                         hoverOverlayRerenders: EMPTY,
                         // Only show on line 24, not line 25 (which is the 2nd click event below).
-                        fetchHover: position =>
-                            position.line === 24 ? createStubHoverFetcher({})(position) : of(null),
-                        fetchActions: position =>
-                            position.line === 24 ? createStubActionsFetcher(['foo', 'bar'])(position) : of(null),
+                        getHover: position => (position.line === 24 ? createStubHoverProvider({})(position) : of(null)),
+                        getActions: position =>
+                            position.line === 24 ? createStubActionsProvider(['foo', 'bar'])(position) : of(null),
                     })
 
                     const positionJumps = new Subject<PositionJump>()
@@ -345,8 +344,8 @@ describe('Hoverifier', () => {
                     closeButtonClicks: new Observable<MouseEvent>(),
                     hoverOverlayElements: of(null),
                     hoverOverlayRerenders: EMPTY,
-                    fetchHover: createStubHoverFetcher(hover, LOADER_DELAY + hoverDelayTime),
-                    fetchActions: createStubActionsFetcher(actions, LOADER_DELAY + actionsDelayTime),
+                    getHover: createStubHoverProvider(hover, LOADER_DELAY + hoverDelayTime),
+                    getActions: createStubActionsProvider(actions, LOADER_DELAY + actionsDelayTime),
                 })
 
                 const positionJumps = new Subject<PositionJump>()
@@ -416,8 +415,8 @@ describe('Hoverifier', () => {
                     closeButtonClicks: new Observable<MouseEvent>(),
                     hoverOverlayElements: of(null),
                     hoverOverlayRerenders: EMPTY,
-                    fetchHover: createStubHoverFetcher(hover),
-                    fetchActions: () => of(null),
+                    getHover: createStubHoverProvider(hover),
+                    getActions: () => of(null),
                 })
 
                 const positionJumps = new Subject<PositionJump>()
@@ -477,8 +476,8 @@ describe('Hoverifier', () => {
                     closeButtonClicks: new Observable<MouseEvent>(),
                     hoverOverlayElements: of(null),
                     hoverOverlayRerenders: EMPTY,
-                    fetchHover: createStubHoverFetcher(hover),
-                    fetchActions: () => of(null),
+                    getHover: createStubHoverProvider(hover),
+                    getActions: () => of(null),
                 })
 
                 const positionJumps = new Subject<PositionJump>()
@@ -533,7 +532,7 @@ describe('Hoverifier', () => {
     /**
      * This test ensures that the adjustPosition options is being called in the ways we expect. This test is actually not the best way to ensure the feature
      * works as expected. This is a good example of a bad side effect of how the main `hoverifier.ts` file is too tightly integrated with itself. Ideally, I'd be able to assert
-     * that the effected positions have actually been adjusted as intended but this is impossible with the current implementation. We can assert that the `HoverFetcher` and `ActionsFetcher`s
+     * that the effected positions have actually been adjusted as intended but this is impossible with the current implementation. We can assert that the `HoverProvider` and `ActionsProvider`s
      * have the adjusted positions (AdjustmentDirection.CodeViewToActual). However, we cannot reliably assert that the code "highlighting" the token has the position adjusted (AdjustmentDirection.ActualToCodeView).
      */
     /**
@@ -546,8 +545,8 @@ describe('Hoverifier', () => {
             scheduler.run(({ cold, expectObservable }) => {
                 const adjustmentDirections = new Subject<AdjustmentDirection>()
 
-                const fetchHover = createStubHoverFetcher({})
-                const fetchActions = createStubActionsFetcher(['foo', 'bar'])
+                const getHover = createStubHoverProvider({})
+                const getActions = createStubActionsProvider(['foo', 'bar'])
 
                 const adjustPosition: PositionAdjuster<{}> = ({ direction, position }) => {
                     adjustmentDirections.next(direction)
@@ -559,8 +558,8 @@ describe('Hoverifier', () => {
                     closeButtonClicks: new Observable<MouseEvent>(),
                     hoverOverlayElements: of(null),
                     hoverOverlayRerenders: EMPTY,
-                    fetchHover,
-                    fetchActions,
+                    getHover,
+                    getActions,
                 })
 
                 const positionJumps = new Subject<PositionJump>()

src/hoverifier.ts

@@ -74,14 +74,14 @@ export interface HoverifierOptions<C extends object, D, A> {
     hoverOverlayElements: Subscribable<HTMLElement | null>
 
     /**
-     * Called to fetch the data to display in the hover.
+     * Called to get the data to display in the hover.
      */
-    fetchHover: HoverFetcher<C, D>
+    getHover: HoverProvider<C, D>
 
     /**
-     * Called to fetch the actions to display in the hover.
+     * Called to get the actions to display in the hover.
      */
-    fetchActions: ActionsFetcher<C, A>
+    getActions: ActionsProvider<C, A>
 }
 
 /**
@@ -150,8 +150,8 @@ export interface AdjustPositionProps<C extends object> {
 }
 
 /**
- * Function to adjust positions coming into and out of hoverifier. It can be used to correct the position used in HoverFetcher and
- * ActionsFetcher requests and the position of th etoken to highlight in the code view. This is useful for code hosts that convert whitespace.
+ * Function to adjust positions coming into and out of hoverifier. It can be used to correct the position used in HoverProvider and
+ * ActionsProvider requests and the position of the token to highlight in the code view. This is useful for code hosts that convert whitespace.
  *
  *
  * @template C Extra context for the hovered token.
@@ -293,15 +293,15 @@ export const MOUSEOVER_DELAY = 50
  * @template C Extra context for the hovered token.
  * @template D The type of the hover content data.
  */
-export type HoverFetcher<C extends object, D> = (
+export type HoverProvider<C extends object, D> = (
     position: HoveredToken & C
 ) => SubscribableOrPromise<(HoverAttachment & D) | null>
 
 /**
  * @template C Extra context for the hovered token.
  * @template A The type of an action.
  */
-export type ActionsFetcher<C extends object, A> = (position: HoveredToken & C) => SubscribableOrPromise<A[] | null>
+export type ActionsProvider<C extends object, A> = (position: HoveredToken & C) => SubscribableOrPromise<A[] | null>
 
 /**
  * Function responsible for resolving the position of a hovered token
@@ -319,8 +319,8 @@ export type ContextResolver<C extends object> = (hoveredToken: HoveredToken) =>
 export function createHoverifier<C extends object, D, A>({
     closeButtonClicks,
     hoverOverlayRerenders,
-    fetchHover,
-    fetchActions,
+    getHover,
+    getActions,
 }: HoverifierOptions<C, D, A>): Hoverifier<C, D, A> {
     // Internal state that is not exposed to the caller
     // Shared between all hoverified code views
@@ -568,21 +568,21 @@ export function createHoverifier<C extends object, D, A>({
             if (!position) {
                 return of({ hoverOrError: null, position: undefined, part: undefined, ...rest })
             }
-            // Fetch the hover for that position
-            const hoverFetch = from(fetchHover(position)).pipe(
+            // Get the hover for that position
+            const hover = from(getHover(position)).pipe(
                 catchError((error): [ErrorLike] => [asError(error)]),
                 share()
             )
-            // 1. Reset the hover content, so no old hover content is displayed at the new position while fetching
-            // 2. Show a loader if the hover fetch hasn't returned after 100ms
+            // 1. Reset the hover content, so no old hover content is displayed at the new position while getting
+            // 2. Show a loader if the hover hasn't returned after 100ms
             // 3. Show the hover once it returned
             return merge(
                 [undefined],
                 of(LOADING).pipe(
                     delay(LOADER_DELAY),
-                    takeUntil(hoverFetch)
+                    takeUntil(hover)
                 ),
-                hoverFetch
+                hover
             ).pipe(
                 map(hoverOrError => ({
                     ...rest,
@@ -685,16 +685,16 @@ export function createHoverifier<C extends object, D, A>({
      * This is a higher-order Observable (Observable that emits Observables).
      */
     const actionObservables = resolvedPositions.pipe(
-        // Fetch the actions for that position
+        // Get the actions for that position
         map(({ position }) => {
             if (!position) {
                 return of(null)
             }
-            return concat([LOADING], from(fetchActions(position)).pipe(catchError(error => [asError(error)])))
+            return concat([LOADING], from(getActions(position)).pipe(catchError(error => [asError(error)])))
         })
     )
 
-    // ACTIONS FETCH
+    // ACTIONS
     // On every new hover position, (pre)fetch actions and update the state
     subscription.add(
         actionObservables
@@ -710,7 +710,7 @@ export function createHoverifier<C extends object, D, A>({
     // if either the hover or the definition turn out non-empty, pin the tooltip.
     // If they both turn out empty, unpin it so we don't end up with an invisible tooltip.
     //
-    // zip together the corresponding hover and definition fetches
+    // zip together the corresponding hover and definition
     subscription.add(
         combineLatest(
             zip(hoverObservables, actionObservables),

src/testutils/fixtures.ts

@@ -1,7 +1,7 @@
 import { of } from 'rxjs'
 import { delay } from 'rxjs/operators'
 
-import { ActionsFetcher, HoverFetcher } from '../hoverifier'
+import { ActionsProvider, HoverProvider } from '../hoverifier'
 import { HoverAttachment } from '../types'
 
 /**
@@ -18,21 +18,24 @@ export const createHoverAttachment = (hover: Partial<HoverAttachment> = {}): Hov
 })
 
 /**
- * Create a stubbed HoverFetcher
+ * Create a stubbed HoverProvider
  * @param hover optional values to be passed to createHoverAttachment
  * @param delayTime optionally delay the hover fetch
  */
-export function createStubHoverFetcher(hover: Partial<HoverAttachment> = {}, delayTime?: number): HoverFetcher<{}, {}> {
+export function createStubHoverProvider(
+    hover: Partial<HoverAttachment> = {},
+    delayTime?: number
+): HoverProvider<{}, {}> {
     return () => of(createHoverAttachment(hover)).pipe(delay(delayTime || 0))
 }
 
 /**
- * Create a stubbed ActionsFetcher
+ * Create a stubbed ActionsProvider
  *
  * @template A The type of an action.
  * @param actions optional value to emit as the actions
  * @param delayTime optionally delay the fetch
  */
-export function createStubActionsFetcher<A>(actions: A[], delayTime?: number): ActionsFetcher<{}, A> {
+export function createStubActionsProvider<A>(actions: A[], delayTime?: number): ActionsProvider<{}, A> {
     return () => of(actions).pipe(delay(delayTime || 0))
 }

src/token_position.ts

@@ -84,7 +84,7 @@ export function convertCodeElementIdempotent(element: HTMLElement): void {
  *
  * The browser extension works by registering a hover event listeners on the <td> element. When the user hovers over
  * "return" (in the first <span> node) the event target will be the <span> node. We can use the event target to determine which line
- * and which character offset on that line to use to fetch tooltip data. But when the user hovers over "Router"
+ * and which character offset on that line to use to get tooltip data. But when the user hovers over "Router"
  * (in the second text node) the event target will be the <td> node, which lacks the appropriate specificity to request
  * tooltip data. To circumvent this, all we need to do is wrap every free text node in a <span> tag.
  *