Suggest relative executables for command word.

Author: vlad-shatskyi

package.json

@@ -33,6 +33,7 @@
     "fuzzaldrin": "2.1.0",
     "immutable": "3.8.1",
     "lodash": "4.13.1",
+    "mode-to-permissions": "0.0.2",
     "node-ansiparser": "2.1.0",
     "pty.js": "shockone/pty.js",
     "react": "15.1.0",

src/PluginManager.ts

@@ -2,11 +2,11 @@ import {OutputDecorator, EnvironmentObserverPlugin, AutocompletionProvider, Pree
 import * as Path from "path";
 import {recursiveFilesIn} from "./utils/Common";
 import {
-    anyFilesSuggestions, environmentVariableSuggestions,
+    anyFilesSuggestionsProvider, environmentVariableSuggestions,
     combineAutocompletionProviders,
 } from "./plugins/autocompletion_providers/Common";
 
-const defaultAutocompletionProvider = combineAutocompletionProviders([environmentVariableSuggestions, anyFilesSuggestions]);
+const defaultAutocompletionProvider = combineAutocompletionProviders([environmentVariableSuggestions, anyFilesSuggestionsProvider]);
 
 // FIXME: Technical debt: register all the plugin types via single method.
 export class PluginManager {

src/plugins/autocompletion_providers/Cd.ts

@@ -1,7 +1,7 @@
 import {expandHistoricalDirectory} from "../../Command";
 import {styles, Suggestion} from "./Suggestions";
 import * as _ from "lodash";
-import {directoriesSuggestions} from "./Common";
+import {directoriesSuggestionsProvider} from "./Common";
 import {PluginManager} from "../../PluginManager";
 
 PluginManager.registerAutocompletionProvider("cd", async(context) => {
@@ -14,12 +14,12 @@ PluginManager.registerAutocompletionProvider("cd", async(context) => {
         suggestions.push(...historicalDirectoryAliases);
     }
 
-    suggestions.push(...await directoriesSuggestions(context));
+    suggestions.push(...await directoriesSuggestionsProvider(context));
 
     if (context.argument.value.length > 0) {
         const cdpathDirectories = _.flatten(await Promise.all(context.environment.cdpath
             .filter(directory => directory !== context.environment.pwd)
-            .map(async(directory) => (await directoriesSuggestions(context, directory)).map(suggestion => suggestion.withDescription(`In ${directory}`)))));
+            .map(async(directory) => (await directoriesSuggestionsProvider(context, directory)).map(suggestion => suggestion.withDescription(`In ${directory}`)))));
 
         suggestions.push(...cdpathDirectories);
     }

src/plugins/autocompletion_providers/Common.ts

@@ -2,17 +2,18 @@ import {statsIn, resolveDirectory, directoryName} from "../../utils/Common";
 import {styles, Suggestion} from "./Suggestions";
 import {FileInfo, SuggestionContext, AutocompletionProvider} from "../../Interfaces";
 import * as Path from "path";
+import * as modeToPermissions from "mode-to-permissions";
 
 function escapePath(path: string) {
     return path.replace(/\s/g, "\\ ");
 }
 
-export const filesSuggestions = (filter: (info: FileInfo) => boolean) => async(context: SuggestionContext, directory = context.environment.pwd): Promise<Suggestion[]> => {
-    const tokenDirectory = directoryName(context.argument.value);
+const filesSuggestions = (filter: (info: FileInfo) => boolean) => async(tokenValue: string, directory: string): Promise<Suggestion[]> => {
+    const tokenDirectory = directoryName(tokenValue);
     const directoryPath = resolveDirectory(directory, tokenDirectory);
     const stats = await statsIn(directoryPath);
 
-    return stats.filter(filter).map(info => {
+    return stats.filter(info => info.stat.isDirectory() || filter(info)).map(info => {
         if (info.stat.isDirectory()) {
             return new Suggestion().withValue(escapePath(Path.join(tokenDirectory, info.name + Path.sep))).withDisplayValue(info.name + Path.sep).withStyle(styles.directory);
         } else {
@@ -21,8 +22,14 @@ export const filesSuggestions = (filter: (info: FileInfo) => boolean) => async(c
     });
 };
 
-export const anyFilesSuggestions = filesSuggestions(() => true);
-export const directoriesSuggestions = filesSuggestions(info => info.stat.isDirectory());
+const filesSuggestionsProvider =
+    (filter: (info: FileInfo) => boolean) =>
+        (context: SuggestionContext, directory = context.environment.pwd): Promise<Suggestion[]> =>
+            filesSuggestions(filter)(context.argument.value, directory);
+
+export const executableFilesSuggestions = filesSuggestions(info => info.stat.isFile() && modeToPermissions(info.stat.mode).execute.owner);
+export const anyFilesSuggestionsProvider = filesSuggestionsProvider(() => true);
+export const directoriesSuggestionsProvider = filesSuggestionsProvider(info => info.stat.isDirectory());
 
 export const environmentVariableSuggestions = async(context: SuggestionContext): Promise<Suggestion[]> => {
     if (context.argument.value.startsWith("$")) {

src/references.ts

@@ -1,4 +1,6 @@
 /// <reference path="../typings/Overrides.d.ts" />
 /// <reference path="../typings/Interfaces.d.ts" />
 
+/// <reference path="../typings/mode-to-permissions.d.ts" />
+
 /// <reference path="../node_modules/immutable/dist/immutable.d.ts" />

src/shell/Parser.ts

@@ -10,7 +10,7 @@ import {PluginManager} from "../PluginManager";
 import {Aliases} from "../Aliases";
 import {
     environmentVariableSuggestions,
-    combineAutocompletionProviders,
+    combineAutocompletionProviders, executableFilesSuggestions,
 } from "../plugins/autocompletion_providers/Common";
 
 export abstract class ASTNode {
@@ -116,12 +116,14 @@ class CommandWord extends LeafNode {
             return [];
         }
 
+        const relativeExecutablesSuggestions = await executableFilesSuggestions(this.value, context.environment.pwd);
         const executables = await executablesInPaths(context.environment.path);
 
         return [
             ...mapObject(context.aliases.toObject(), (key, value) => new Suggestion().withValue(`${key} `).withDescription(value).withStyle(styles.alias)),
             ...loginShell.preCommandModifiers.map(modifier => new Suggestion().withValue(`${modifier} `).withStyle(styles.func)),
             ...executables.map(name => new Suggestion().withValue(`${name} `).withDescription(commandDescriptions[name] || "").withStyle(styles.executable)),
+            ...relativeExecutablesSuggestions,
         ];
     }
 }

typings/mode-to-permissions.d.ts

@@ -0,0 +1,17 @@
+interface PermittedGroups {
+    owner: boolean;
+    group: boolean;
+    others: boolean;
+}
+
+interface Permissions {
+    read: PermittedGroups;
+    write: PermittedGroups;
+    execute: PermittedGroups;
+}
+
+declare module "mode-to-permissions" {
+    function modeToPermissions(mode: number): Permissions;
+    namespace modeToPermissions {}
+    export = modeToPermissions;
+}