Explorer: Locate Current Buffer

browser/src/Services/Explorer/ExplorerFileSystem.ts

@@ -18,6 +18,7 @@ import { FolderOrFile } from "./ExplorerStore"
 export interface IFileSystem {
     readdir(fullPath: string): Promise<FolderOrFile[]>
     exists(fullPath: string): Promise<boolean>
+    realpath(fullPath: string): Promise<string>
     persistNode(fullPath: string): Promise<void>
     restoreNode(fullPath: string): Promise<void>
     deleteNode(fullPath: string): Promise<void>
@@ -33,6 +34,7 @@ export class FileSystem implements IFileSystem {
         readdir(path: string): Promise<string[]>
         stat(path: string): Promise<fs.Stats>
         exists(path: string): Promise<boolean>
+        realpath(path: string): Promise<string>
     }
 
     private _backupDirectory = path.join(os.tmpdir(), "oni_backup")
@@ -46,6 +48,7 @@ export class FileSystem implements IFileSystem {
             readdir: promisify(nfs.readdir.bind(nfs)),
             stat: promisify(nfs.stat.bind(nfs)),
             exists: promisify(nfs.exists.bind(nfs)),
+            realpath: promisify(nfs.realpath.bind(nfs)),
         }
 
         this.init()
@@ -84,6 +87,13 @@ export class FileSystem implements IFileSystem {
         return this._fs.exists(fullPath)
     }
 
+    /**
+     * Resolve symlinks in a path to give the real absolute path.
+     */
+    public realpath(fullPath: string): Promise<string> {
+        return this._fs.realpath(fullPath)
+    }
+
     /**
      * Delete a file or Folder
      *

browser/src/Services/Explorer/ExplorerSplit.tsx

@@ -99,6 +99,10 @@ export class ExplorerSplit {
         )
     }
 
+    public locateFile = (filePath: string) => {
+        this._store.dispatch({ type: "SELECT_FILE", filePath })
+    }
+
     private _initializeFileSystemWatcher(): void {
         if (this._configuration.getValue("explorer.autoRefresh")) {
             this._watcher = new FileSystemWatcher({
@@ -223,6 +227,14 @@ export class ExplorerSplit {
 
     private _onSelectionChanged(id: string): void {
         this._selectedId = id
+        // If we are trying to select a file, check if it's now selected, and if so trigger success.
+        const fileToSelect: string = this._store.getState().fileToSelect
+        if (fileToSelect) {
+            const selectedPath: string = getPathForNode(this._getSelectedItem())
+            if (selectedPath === fileToSelect) {
+                this._store.dispatch({ type: "SELECT_FILE_SUCCESS" })
+            }
+        }
     }
 
     private _onOpenItem(id?: string): void {

browser/src/Services/Explorer/ExplorerStore.ts

@@ -107,14 +107,15 @@ export interface IExplorerState {
     rootFolder: IFolderState
 
     expandedFolders: ExpandedFolders
-
+    fileToSelect: string
     hasFocus: boolean
     register: IRegisterState
 }
 
 export const DefaultExplorerState: IExplorerState = {
     rootFolder: null,
     expandedFolders: {},
+    fileToSelect: null,
     hasFocus: false,
     register: DefaultRegisterState,
 }
@@ -192,6 +193,25 @@ export interface IExpandDirectoryResult {
     children: FolderOrFile[]
 }
 
+export interface ISelectFileAction {
+    type: "SELECT_FILE"
+    filePath: string
+}
+
+export interface ISelectFilePendingAction {
+    type: "SELECT_FILE_PENDING"
+    filePath: string
+}
+
+export interface ISelectFileSuccessAction {
+    type: "SELECT_FILE_SUCCESS"
+}
+
+export interface ISelectFileFailAction {
+    type: "SELECT_FILE_FAIL"
+    reason: string
+}
+
 export interface IEnterAction {
     type: "ENTER"
 }
@@ -308,6 +328,10 @@ export type ExplorerAction =
     | ICreateNodeCommitAction
     | ICreateNodeSuccessAction
     | INotificationSentAction
+    | ISelectFileAction
+    | ISelectFilePendingAction
+    | ISelectFileSuccessAction
+    | ISelectFileFailAction
 
 // Helper functions for Updating state ========================================================
 export const removePastedNode = (nodeArray: ExplorerNode[], ids: string[]): ExplorerNode[] =>
@@ -613,6 +637,20 @@ export const hasFocusReducer: Reducer<boolean> = (
     }
 }
 
+export const selectFileReducer: Reducer<string> = (
+    state: string = null,
+    action: ExplorerAction,
+) => {
+    switch (action.type) {
+        case "SELECT_FILE_PENDING":
+            return action.filePath
+        case "SELECT_FILE_SUCCESS":
+            return null
+        default:
+            return state
+    }
+}
+
 export const reducer: Reducer<IExplorerState> = (
     state: IExplorerState = DefaultExplorerState,
     action: ExplorerAction,
@@ -622,6 +660,7 @@ export const reducer: Reducer<IExplorerState> = (
         hasFocus: hasFocusReducer(state.hasFocus, action),
         rootFolder: rootFolderReducer(state.rootFolder, action),
         expandedFolders: expandedFolderReducer(state.expandedFolders, action),
+        fileToSelect: selectFileReducer(state.fileToSelect, action),
         register: yankRegisterReducer(state.register, action),
     }
 }
@@ -920,6 +959,44 @@ const expandDirectoryEpic: ExplorerEpic = (action$, store, { fileSystem }) =>
         return Actions.expandDirectoryResult(pathToExpand, sortedFilesAndFolders)
     })
 
+export const selectFileEpic: ExplorerEpic = (action$, store, { fileSystem }) =>
+    action$.ofType("SELECT_FILE").mergeMap(({ filePath }: ISelectFileAction) => {
+        const rootPath = store.getState().rootFolder.fullPath
+
+        // We need to resolve any symlinks, since the buffer and workspace path can otherwise
+        // appear to be unrelated (at least on OSX).
+        return fromPromise(
+            Promise.all([fileSystem.realpath(rootPath), fileSystem.realpath(filePath)]),
+        ).flatMap(([realRootPath, realFilePath]): ExplorerAction[] => {
+            const relPath = path.relative(realRootPath, realFilePath)
+            // Can only select files in the workspace.
+            if (relPath.startsWith("..") || path.isAbsolute(relPath)) {
+                const failure: ISelectFileFailAction = {
+                    type: "SELECT_FILE_FAIL",
+                    reason: `File is not in workspace: ${filePath}`,
+                }
+                return [failure]
+            }
+            // Get the list of directories to expand in the Explorer.
+            const relDirectoryPath = path.relative(realRootPath, path.dirname(realFilePath))
+            const directories = relDirectoryPath.split(path.sep)
+            const actions = []
+            // Expand each directory in turn from the project root down to the file we want.
+            for (let dirNum = 1; dirNum <= directories.length; dirNum++) {
+                const relParentDirectoryPath = directories.slice(0, dirNum).join(path.sep)
+                const parentDirectoryPath = path.join(rootPath, relParentDirectoryPath)
+                actions.push(Actions.expandDirectory(parentDirectoryPath))
+            }
+            // Update the state with the file path we want the VimNaviator to select.
+            const pending: ISelectFilePendingAction = {
+                type: "SELECT_FILE_PENDING",
+                filePath: realFilePath,
+            }
+            actions.push(pending)
+            return actions
+        })
+    })
+
 export const createNodeEpic: ExplorerEpic = (action$, store, { fileSystem }) =>
     action$.ofType("CREATE_NODE_COMMIT").mergeMap(({ name }: ICreateNodeCommitAction) => {
         const {
@@ -946,6 +1023,7 @@ export const notificationEpic: ExplorerEpic = (action$, store, { notifications }
             "PASTE_FAIL",
             "DELETE_FAIL",
             "CREATE_NODE_FAIL",
+            "SELECT_FILE_FAIL",
         )
         .map(action => {
             switch (action.type) {
@@ -985,6 +1063,7 @@ export const notificationEpic: ExplorerEpic = (action$, store, { notifications }
                 case "DELETE_FAIL":
                 case "RENAME_FAIL":
                 case "CREATE_NODE_FAIL":
+                case "SELECT_FILE_FAIL":
                     const [type] = action.type.split("_")
                     errorNotification({
                         type,
@@ -1019,6 +1098,7 @@ export const createStore = ({
                 undoEpic,
                 deleteEpic,
                 expandDirectoryEpic,
+                selectFileEpic,
                 notificationEpic,
             ),
             { dependencies: { fileSystem, notifications } },

browser/src/Services/Explorer/ExplorerView.tsx

@@ -21,7 +21,7 @@ import { DragAndDrop, Droppeable } from "./../DragAndDrop"
 import { FileIcon } from "./../FileIcon"
 
 import * as ExplorerSelectors from "./ExplorerSelectors"
-import { IExplorerState } from "./ExplorerStore"
+import { getPathForNode, IExplorerState } from "./ExplorerStore"
 
 type Node = ExplorerSelectors.ExplorerNode
 
@@ -267,6 +267,7 @@ export interface IExplorerViewProps extends IExplorerViewContainerProps {
     nodes: ExplorerSelectors.ExplorerNode[]
     isActive: boolean
     updated: string[]
+    idToSelect: string
 }
 
 import { SidebarEmptyPaneView } from "./../../UI/components/SidebarEmptyPaneView"
@@ -293,6 +294,7 @@ export class ExplorerView extends React.PureComponent<IExplorerViewProps, {}> {
                 <VimNavigator
                     ids={ids}
                     active={this.props.isActive && !this.props.isRenaming && !this.props.isCreating}
+                    idToSelect={this.props.idToSelect}
                     onSelectionChanged={this.props.onSelectionChanged}
                     onSelected={id => this.props.onClick(id)}
                     render={(selectedId: string) => {
@@ -334,13 +336,30 @@ const mapStateToProps = (
     const yanked = state.register.yank.map(node => node.id)
     const {
         register: { updated, rename },
+        fileToSelect,
     } = state
+
+    const nodes: ExplorerSelectors.ExplorerNode[] = ExplorerSelectors.mapStateToNodeList(state)
+
+    let idToSelect: string = null
+    // If parent has told us to select a file, attempt to convert the file path into a node ID.
+    if (fileToSelect) {
+        const [nodeToSelect] = nodes.filter((node: ExplorerSelectors.ExplorerNode) => {
+            const nodePath: string = getPathForNode(node)
+            return nodePath === fileToSelect
+        })
+        if (nodeToSelect) {
+            idToSelect = nodeToSelect.id
+        }
+    }
+
     return {
         ...containerProps,
         isActive: state.hasFocus,
-        nodes: ExplorerSelectors.mapStateToNodeList(state),
+        nodes,
         updated,
         yanked,
+        idToSelect,
         isCreating: state.register.create.active,
         isRenaming: rename.active && rename.target,
     }

browser/src/Services/Explorer/index.tsx

@@ -4,13 +4,12 @@
  * Entry point for explorer-related features
  */
 
-import { CommandManager } from "./../CommandManager"
+import { IWorkspace } from "./../../Services/Workspace"
+import { CallbackCommand, CommandManager } from "./../CommandManager"
 import { Configuration } from "./../Configuration"
 import { EditorManager } from "./../EditorManager"
 import { SidebarManager } from "./../Sidebar"
 
-import { IWorkspace } from "./../../Services/Workspace"
-
 import { ExplorerSplit } from "./ExplorerSplit"
 
 export const activate = (
@@ -27,20 +26,38 @@ export const activate = (
         defaultValue: false,
     })
 
-    sidebarManager.add(
-        "files-o",
-        new ExplorerSplit(configuration, workspace, commandManager, editorManager),
+    const explorerSplit: ExplorerSplit = new ExplorerSplit(
+        configuration,
+        workspace,
+        commandManager,
+        editorManager,
     )
+    sidebarManager.add("files-o", explorerSplit)
 
-    const toggleExplorer = () => {
-        sidebarManager.toggleVisibilityById("oni.sidebar.explorer")
-    }
+    const explorerId = "oni.sidebar.explorer"
 
-    commandManager.registerCommand({
-        command: "explorer.toggle",
-        name: "Explorer: Toggle Visibility",
-        detail: "Toggles the explorer in the sidebar",
-        execute: toggleExplorer,
-        enabled: () => !!workspace.activeWorkspace,
-    })
+    commandManager.registerCommand(
+        new CallbackCommand(
+            "explorer.toggle",
+            "Explorer: Toggle Visibility",
+            "Toggles the explorer in the sidebar",
+            () => sidebarManager.toggleVisibilityById(explorerId),
+            () => !!workspace.activeWorkspace,
+        ),
+    )
+
+    commandManager.registerCommand(
+        new CallbackCommand(
+            "explorer.locate.buffer",
+            "Explorer: Locate Current Buffer",
+            "Locate current buffer in file tree",
+            () => {
+                if (sidebarManager.activeEntryId !== explorerId || !sidebarManager.isVisible) {
+                    sidebarManager.setActiveEntry(explorerId)
+                }
+                explorerSplit.locateFile(editorManager.activeEditor.activeBuffer.filePath)
+            },
+            () => !!workspace.activeWorkspace,
+        ),
+    )
 }

browser/src/Services/Sidebar/SidebarStore.ts

@@ -62,6 +62,10 @@ export class SidebarManager {
         return this._contentSplit.isFocused
     }
 
+    get isVisible(): boolean {
+        return this._contentSplit.isVisible
+    }
+
     public get store(): Store<ISidebarState> {
         return this._store
     }

browser/src/UI/components/VimNavigator.tsx

@@ -35,6 +35,7 @@ export interface IVimNavigatorProps {
     render: (selectedId: string) => JSX.Element
 
     style?: React.CSSProperties
+    idToSelect?: string
 }
 
 export interface IVimNavigatorState {
@@ -127,16 +128,7 @@ export class VimNavigator extends React.PureComponent<IVimNavigatorProps, IVimNa
 
             this._activeBinding.onCursorMoved.subscribe(newValue => {
                 Log.info("[VimNavigator::onCursorMoved] - " + newValue)
-
-                if (newValue !== this.state.selectedId) {
-                    this.setState({
-                        selectedId: newValue,
-                    })
-
-                    if (this.props.onSelectionChanged) {
-                        this.props.onSelectionChanged(newValue)
-                    }
-                }
+                this._maybeUpdateSelection(newValue)
             })
 
             await this._activeBinding.setItems(this.props.ids, this.state.selectedId)
@@ -146,5 +138,19 @@ export class VimNavigator extends React.PureComponent<IVimNavigatorProps, IVimNa
         } else if (!props.active && this._activeBinding) {
             this._releaseBinding()
         }
+
+        if (props.idToSelect) {
+            this._maybeUpdateSelection(props.idToSelect)
+        }
+    }
+
+    private _maybeUpdateSelection(id: string) {
+        if (id !== this.state.selectedId) {
+            this.setState({ selectedId: id })
+
+            if (this.props.onSelectionChanged) {
+                this.props.onSelectionChanged(id)
+            }
+        }
     }
 }