Install and enable completion on user system. It'll ask for:
6 |Public: Main utility to extract information from command line arguments and 13 | Environment variables, namely COMP args in "plumbing" mode.
14 |options - The options hash as parsed by minimist, plus an env property 15 | representing user environment (default: { env: process.env }) 16 | :_ - The arguments Array parsed by minimist (positional arguments) 17 | :env - The environment Object that holds COMP args (default: process.env)
18 |Examples
19 |const env = tabtab.parseEnv(); 20 | // env: 21 | // complete A Boolean indicating whether we act in "plumbing mode" or not 22 | // words The Number of words in the completed line 23 | // point A Number indicating cursor position 24 | // line The String input line 25 | // partial The String part of line preceding cursor position 26 | // last The last String word of the line 27 | // lastPartial The last word String of partial 28 | // prev The String word preceding last
29 |Returns the data env object.
30 |Helper to normalize String and Objects with { name, description } when logging out.
33 |Main logging utility to pass completion items.
36 |This is simply an helper to log to stdout with each item separated by a new 37 | line.
38 |Bash needs in addition to filter out the args for the completion to work 39 | (zsh, fish don't need this).
40 |Object | to use with namely `name` and `completer` |
56 |
57 |
58 |
59 | ## parseEnv()
60 | Public: Main utility to extract information from command line arguments and
61 | Environment variables, namely COMP args in "plumbing" mode.
62 |
63 | options - The options hash as parsed by minimist, plus an env property
64 | representing user environment (default: { env: process.env })
65 | :_ - The arguments Array parsed by minimist (positional arguments)
66 | :env - The environment Object that holds COMP args (default: process.env)
67 |
68 | Examples
69 |
70 | const env = tabtab.parseEnv();
71 | // env:
72 | // complete A Boolean indicating whether we act in "plumbing mode" or not
73 | // words The Number of words in the completed line
74 | // point A Number indicating cursor position
75 | // line The String input line
76 | // partial The String part of line preceding cursor position
77 | // last The last String word of the line
78 | // lastPartial The last word String of partial
79 | // prev The String word preceding last
80 |
81 | Returns the data env object.
82 |
83 | **Kind**: global function
84 |
85 |
86 | ## completionItem(item)
87 | Helper to normalize String and Objects with { name, description } when logging out.
88 |
89 | **Kind**: global function
90 |
91 | | Param | Type | Description |
92 | | --- | --- | --- |
93 | | item | String \| Object | Item to normalize |
94 |
95 |
96 |
97 | ## log(Arguments)
98 | Main logging utility to pass completion items.
99 |
100 | This is simply an helper to log to stdout with each item separated by a new
101 | line.
102 |
103 | Bash needs in addition to filter out the args for the completion to work
104 | (zsh, fish don't need this).
105 |
106 | **Kind**: global function
107 |
108 | | Param | Type | Description |
109 | | --- | --- | --- |
110 | | Arguments | Array | to log, Strings or Objects with name and description property. |
111 |
112 |
--------------------------------------------------------------------------------
/lib/index.js:
--------------------------------------------------------------------------------
1 | const prompt = require('./prompt');
2 | const installer = require('./installer');
3 | const { tabtabDebug, systemShell } = require('./utils');
4 |
5 | // If TABTAB_DEBUG env is set, make it so that debug statements are also log to
6 | // TABTAB_DEBUG file provided.
7 | const debug = tabtabDebug('tabtab');
8 |
9 | /**
10 | * Install and enable completion on user system. It'll ask for:
11 | *
12 | * - SHELL (bash, zsh or fish)
13 | * - Path to shell script (with sensible defaults)
14 | *
15 | * @param {Object} Options to use with namely `name` and `completer`
16 | *
17 | */
18 | const install = async (options = { name: '', completer: '' }) => {
19 | const { name, completer } = options;
20 | if (!name) throw new TypeError('options.name is required');
21 | if (!completer) throw new TypeError('options.completer is required');
22 |
23 | return prompt().then(({ location }) =>
24 | installer.install({
25 | name,
26 | completer,
27 | location
28 | })
29 | );
30 | };
31 |
32 | const uninstall = async (options = { name: '' }) => {
33 | const { name } = options;
34 | if (!name) throw new TypeError('options.name is required');
35 |
36 | return installer
37 | .uninstall({ name })
38 | .catch(err => console.error('ERROR while uninstalling', err));
39 | };
40 |
41 | /**
42 | * Public: Main utility to extract information from command line arguments and
43 | * Environment variables, namely COMP args in "plumbing" mode.
44 | *
45 | * options - The options hash as parsed by minimist, plus an env property
46 | * representing user environment (default: { env: process.env })
47 | * :_ - The arguments Array parsed by minimist (positional arguments)
48 | * :env - The environment Object that holds COMP args (default: process.env)
49 | *
50 | * Examples
51 | *
52 | * const env = tabtab.parseEnv();
53 | * // env:
54 | * // complete A Boolean indicating whether we act in "plumbing mode" or not
55 | * // words The Number of words in the completed line
56 | * // point A Number indicating cursor position
57 | * // line The String input line
58 | * // partial The String part of line preceding cursor position
59 | * // last The last String word of the line
60 | * // lastPartial The last word String of partial
61 | * // prev The String word preceding last
62 | *
63 | * Returns the data env object.
64 | */
65 | const parseEnv = env => {
66 | if (!env) {
67 | throw new Error('parseEnv: You must pass in an environment object.');
68 | }
69 |
70 | debug(
71 | 'Parsing env. CWORD: %s, COMP_POINT: %s, COMP_LINE: %s',
72 | env.COMP_CWORD,
73 | env.COMP_POINT,
74 | env.COMP_LINE
75 | );
76 |
77 | let cword = Number(env.COMP_CWORD);
78 | let point = Number(env.COMP_POINT);
79 | const line = env.COMP_LINE || '';
80 |
81 | if (Number.isNaN(cword)) cword = 0;
82 | if (Number.isNaN(point)) point = 0;
83 |
84 | const partial = line.slice(0, point);
85 |
86 | const parts = line.split(' ');
87 | const prev = parts.slice(0, -1).slice(-1)[0];
88 |
89 | const last = parts.slice(-1).join('');
90 | const lastPartial = partial
91 | .split(' ')
92 | .slice(-1)
93 | .join('');
94 |
95 | let complete = true;
96 | if (!env.COMP_CWORD || !env.COMP_POINT || !env.COMP_LINE) {
97 | complete = false;
98 | }
99 |
100 | return {
101 | complete,
102 | words: cword,
103 | point,
104 | line,
105 | partial,
106 | last,
107 | lastPartial,
108 | prev
109 | };
110 | };
111 |
112 | /**
113 | * Helper to normalize String and Objects with { name, description } when logging out.
114 | *
115 | * @param {String|Object} item - Item to normalize
116 | */
117 | const completionItem = item => {
118 | debug('completion item', item);
119 |
120 | if (item.name || item.description) return item;
121 | const shell = systemShell();
122 |
123 | let name = item;
124 | let description = '';
125 | const matching = /^(.*?)(\\)?:(.*)$/.exec(item);
126 | if (matching) {
127 | [, name, , description] = matching;
128 | }
129 |
130 | if (shell === 'zsh' && /\\/.test(item)) {
131 | name += '\\';
132 | }
133 |
134 | return {
135 | name,
136 | description
137 | };
138 | };
139 |
140 | /**
141 | * Main logging utility to pass completion items.
142 | *
143 | * This is simply an helper to log to stdout with each item separated by a new
144 | * line.
145 | *
146 | * Bash needs in addition to filter out the args for the completion to work
147 | * (zsh, fish don't need this).
148 | *
149 | * @param {Array} Arguments to log, Strings or Objects with name and
150 | * description property.
151 | */
152 | const log = args => {
153 | const shell = systemShell();
154 |
155 | if (!Array.isArray(args)) {
156 | throw new Error('log: Invalid arguments, must be an array');
157 | }
158 |
159 | // Normalize arguments if there are some Objects { name, description } in them.
160 | args = args.map(completionItem).map(item => {
161 | const { name, description } = item;
162 | let str = name;
163 | if (shell === 'zsh' && description) {
164 | str = `${name.replace(/:/g, '\\:')}:${description}`;
165 | } else if (shell === 'fish' && description) {
166 | str = `${name}\t${description}`;
167 | }
168 |
169 | return str;
170 | });
171 |
172 | if (shell === 'bash') {
173 | const env = parseEnv(process.env);
174 | args = args.filter(arg => arg.indexOf(env.last) === 0);
175 | }
176 |
177 | for (const arg of args) {
178 | console.log(`${arg}`);
179 | }
180 | };
181 |
182 | module.exports = {
183 | shell: systemShell,
184 | install,
185 | uninstall,
186 | parseEnv,
187 | log
188 | };
189 |
--------------------------------------------------------------------------------
/api/installer.js.md:
--------------------------------------------------------------------------------
1 | ## Functions
2 |
3 | Little helper to return the correct file extension based on the SHELL value.
6 |Helper to return the correct script template based on the SHELL provided
9 |StringHelper to return the expected location for SHELL config file, based on the 12 | provided shell value.
13 |Helper to return the source line to add depending on the SHELL provided or detected.
16 |If the provided SHELL is not known, it returns the source line for a Bash shell.
17 |BooleanHelper to check if a filename is one of the SHELL config we expect
20 |BooleanChecks a given file for the existence of a specific line. Used to prevent 23 | adding multiple completion source to SHELL scripts.
24 |Opens a file for modification adding a new source line for the given
27 | SHELL. Used for both SHELL script and tabtab internal one.
Writes to SHELL config file adding a new line, but only one, to the SHELL 31 | config script. This enables tabtab to work for the given SHELL.
32 |Writes to tabtab internal script that acts as a frontend router for the 35 | completion mechanism, in the internal ~/.config/tabtab directory. Every 36 | completion is added to this file.
37 |This writes a new completion script in the internal ~/.config/tabtab
40 | directory. Depending on the SHELL used, a different script is created for
41 | the given SHELL.
Top level install method. Does three things:
45 |Removes the 3 relevant lines from provided filename, based on the package 53 | name passed in.
54 |Here the idea is to uninstall a given package completion from internal 57 | tabtab scripts and / or the SHELL config.
58 |It also removes the relevant scripts if no more completion are installed on 59 | the system.
60 |String | Shell to base the check on, defaults to system shell. |
81 |
82 |
83 |
84 | ## locationFromShell(shell) ⇒ String
85 | Helper to return the expected location for SHELL config file, based on the
86 | provided shell value.
87 |
88 | **Kind**: global function
89 | **Returns**: String - Either ~/.bashrc, ~/.zshrc or ~/.config/fish/config.fish,
90 | untildified. Defaults to ~/.bashrc if provided SHELL is not valid.
91 |
92 | | Param | Type | Description |
93 | | --- | --- | --- |
94 | | shell | String | Shell value to test against |
95 |
96 |
97 |
98 | ## sourceLineForShell(scriptname, shell)
99 | Helper to return the source line to add depending on the SHELL provided or detected.
100 |
101 | If the provided SHELL is not known, it returns the source line for a Bash shell.
102 |
103 | **Kind**: global function
104 |
105 | | Param | Type | Description |
106 | | --- | --- | --- |
107 | | scriptname | String | The script to source |
108 | | shell | String | Shell to base the check on, defaults to system shell. |
109 |
110 |
111 |
112 | ## isInShellConfig(filename) ⇒ Boolean
113 | Helper to check if a filename is one of the SHELL config we expect
114 |
115 | **Kind**: global function
116 | **Returns**: Boolean - Either true or false
117 |
118 | | Param | Type | Description |
119 | | --- | --- | --- |
120 | | filename | String | Filename to check against |
121 |
122 |
123 |
124 | ## checkFilenameForLine(filename, line) ⇒ Boolean
125 | Checks a given file for the existence of a specific line. Used to prevent
126 | adding multiple completion source to SHELL scripts.
127 |
128 | **Kind**: global function
129 | **Returns**: Boolean - true or false, false if the line is not present.
130 |
131 | | Param | Type | Description |
132 | | --- | --- | --- |
133 | | filename | String | The filename to check against |
134 | | line | String | The line to look for |
135 |
136 |
137 |
138 | ## writeLineToFilename(options)
139 | Opens a file for modification adding a new `source` line for the given
140 | SHELL. Used for both SHELL script and tabtab internal one.
141 |
142 | **Kind**: global function
143 |
144 | | Param | Type | Description |
145 | | --- | --- | --- |
146 | | options | Object | Options with - filename: The file to modify - scriptname: The line to add sourcing this file - name: The package being configured |
147 |
148 |
149 |
150 | ## writeToShellConfig(options)
151 | Writes to SHELL config file adding a new line, but only one, to the SHELL
152 | config script. This enables tabtab to work for the given SHELL.
153 |
154 | **Kind**: global function
155 |
156 | | Param | Type | Description |
157 | | --- | --- | --- |
158 | | options | Object | Options object with - location: The SHELL script location (~/.bashrc, ~/.zshrc or ~/.config/fish/config.fish) - name: The package configured for completion |
159 |
160 |
161 |
162 | ## writeToTabtabScript(options)
163 | Writes to tabtab internal script that acts as a frontend router for the
164 | completion mechanism, in the internal ~/.config/tabtab directory. Every
165 | completion is added to this file.
166 |
167 | **Kind**: global function
168 |
169 | | Param | Type | Description |
170 | | --- | --- | --- |
171 | | options | Object | Options object with - name: The package configured for completion |
172 |
173 |
174 |
175 | ## writeToCompletionScript(options)
176 | This writes a new completion script in the internal `~/.config/tabtab`
177 | directory. Depending on the SHELL used, a different script is created for
178 | the given SHELL.
179 |
180 | **Kind**: global function
181 |
182 | | Param | Type | Description |
183 | | --- | --- | --- |
184 | | options | Object | Options object with - name: The package configured for completion - completer: The binary that will act as the completer for `name` program |
185 |
186 |
187 |
188 | ## install(options)
189 | Top level install method. Does three things:
190 |
191 | - Writes to SHELL config file, adding a new line to tabtab internal script.
192 | - Creates or edit tabtab internal script
193 | - Creates the actual completion script for this package.
194 |
195 | **Kind**: global function
196 |
197 | | Param | Type | Description |
198 | | --- | --- | --- |
199 | | options | Object | Options object with - name: The program name to complete - completer: The actual program or binary that will act as the completer for `name` program. Can be the same. - location: The SHELL script config location (~/.bashrc, ~/.zshrc or ~/.config/fish/config.fish) |
200 |
201 |
202 |
203 | ## removeLinesFromFilename(filename, name)
204 | Removes the 3 relevant lines from provided filename, based on the package
205 | name passed in.
206 |
207 | **Kind**: global function
208 |
209 | | Param | Type | Description |
210 | | --- | --- | --- |
211 | | filename | String | The filename to operate on |
212 | | name | String | The package name to look for |
213 |
214 |
215 |
216 | ## uninstall(options)
217 | Here the idea is to uninstall a given package completion from internal
218 | tabtab scripts and / or the SHELL config.
219 |
220 | It also removes the relevant scripts if no more completion are installed on
221 | the system.
222 |
223 | **Kind**: global function
224 |
225 | | Param | Type | Description |
226 | | --- | --- | --- |
227 | | options | Object | Options object with - name: The package name to look for |
228 |
229 |
--------------------------------------------------------------------------------
/lib/installer.js:
--------------------------------------------------------------------------------
1 | const fs = require('fs');
2 | const path = require('path');
3 | const untildify = require('untildify');
4 | const { promisify } = require('es6-promisify');
5 | const mkdirp = promisify(require('mkdirp'));
6 | const { tabtabDebug, systemShell, exists } = require('./utils');
7 |
8 | const debug = tabtabDebug('tabtab:installer');
9 |
10 | const readFile = promisify(fs.readFile);
11 | const writeFile = promisify(fs.writeFile);
12 | const unlink = promisify(fs.unlink);
13 |
14 | const {
15 | BASH_LOCATION,
16 | FISH_LOCATION,
17 | ZSH_LOCATION,
18 | COMPLETION_DIR,
19 | TABTAB_SCRIPT_NAME
20 | } = require('./constants');
21 |
22 | /**
23 | * Little helper to return the correct file extension based on the SHELL value.
24 | *
25 | * @returns The correct file extension for the given SHELL script location
26 | */
27 | const shellExtension = () => systemShell();
28 |
29 | /**
30 | * Helper to return the correct script template based on the SHELL provided
31 | *
32 | * @param {String} shell - Shell to base the check on, defaults to system shell.
33 | * @returns The template script content, defaults to Bash for shell we don't know yet
34 | */
35 | const scriptFromShell = (shell = systemShell()) => {
36 | if (shell === 'fish') {
37 | return path.join(__dirname, 'scripts/fish.sh');
38 | }
39 |
40 | if (shell === 'zsh') {
41 | return path.join(__dirname, 'scripts/zsh.sh');
42 | }
43 |
44 | // For Bash and others
45 | return path.join(__dirname, 'scripts/bash.sh');
46 | };
47 |
48 | /**
49 | * Helper to return the expected location for SHELL config file, based on the
50 | * provided shell value.
51 | *
52 | * @param {String} shell - Shell value to test against
53 | * @returns {String} Either ~/.bashrc, ~/.zshrc or ~/.config/fish/config.fish,
54 | * untildified. Defaults to ~/.bashrc if provided SHELL is not valid.
55 | */
56 | const locationFromShell = (shell = systemShell()) => {
57 | if (shell === 'bash') return untildify(BASH_LOCATION);
58 | if (shell === 'zsh') return untildify(ZSH_LOCATION);
59 | if (shell === 'fish') return untildify(FISH_LOCATION);
60 | return BASH_LOCATION;
61 | };
62 |
63 | /**
64 | * Helper to return the source line to add depending on the SHELL provided or detected.
65 | *
66 | * If the provided SHELL is not known, it returns the source line for a Bash shell.
67 | *
68 | * @param {String} scriptname - The script to source
69 | * @param {String} shell - Shell to base the check on, defaults to system
70 | * shell.
71 | */
72 | const sourceLineForShell = (scriptname, shell = systemShell()) => {
73 | if (shell === 'fish') {
74 | return `[ -f ${scriptname} ]; and . ${scriptname}; or true`;
75 | }
76 |
77 | if (shell === 'zsh') {
78 | return `[[ -f ${scriptname} ]] && . ${scriptname} || true`;
79 | }
80 |
81 | // For Bash and others
82 | return `[ -f ${scriptname} ] && . ${scriptname} || true`;
83 | };
84 |
85 | /**
86 | * Helper to check if a filename is one of the SHELL config we expect
87 | *
88 | * @param {String} filename - Filename to check against
89 | * @returns {Boolean} Either true or false
90 | */
91 | const isInShellConfig = filename =>
92 | [
93 | BASH_LOCATION,
94 | ZSH_LOCATION,
95 | FISH_LOCATION,
96 | untildify(BASH_LOCATION),
97 | untildify(ZSH_LOCATION),
98 | untildify(FISH_LOCATION)
99 | ].includes(filename);
100 |
101 | /**
102 | * Checks a given file for the existence of a specific line. Used to prevent
103 | * adding multiple completion source to SHELL scripts.
104 | *
105 | * @param {String} filename - The filename to check against
106 | * @param {String} line - The line to look for
107 | * @returns {Boolean} true or false, false if the line is not present.
108 | */
109 | const checkFilenameForLine = async (filename, line) => {
110 | debug('Check filename (%s) for "%s"', filename, line);
111 |
112 | let filecontent = '';
113 | try {
114 | filecontent = await readFile(untildify(filename), 'utf8');
115 | } catch (err) {
116 | if (err.code !== 'ENOENT') {
117 | return console.error(
118 | 'Got an error while trying to read from %s file',
119 | filename,
120 | err
121 | );
122 | }
123 | }
124 |
125 | return !!filecontent.match(`${line}`);
126 | };
127 |
128 | /**
129 | * Opens a file for modification adding a new `source` line for the given
130 | * SHELL. Used for both SHELL script and tabtab internal one.
131 | *
132 | * @param {Object} options - Options with
133 | * - filename: The file to modify
134 | * - scriptname: The line to add sourcing this file
135 | * - name: The package being configured
136 | */
137 | const writeLineToFilename = ({ filename, scriptname, name }) => (
138 | resolve,
139 | reject
140 | ) => {
141 | const filepath = untildify(filename);
142 |
143 | debug('Creating directory for %s file', filepath);
144 | mkdirp(path.dirname(filepath))
145 | .then(() => {
146 | const stream = fs.createWriteStream(filepath, { flags: 'a' });
147 | stream.on('error', reject);
148 | stream.on('finish', () => resolve());
149 |
150 | debug('Writing to shell configuration file (%s)', filename);
151 | debug('scriptname:', scriptname);
152 |
153 | const inShellConfig = isInShellConfig(filename);
154 | if (inShellConfig) {
155 | stream.write(`\n# tabtab source for packages`);
156 | } else {
157 | stream.write(`\n# tabtab source for ${name} package`);
158 | }
159 |
160 | stream.write('\n# uninstall by removing these lines');
161 | stream.write(`\n${sourceLineForShell(scriptname)}`);
162 | stream.end('\n');
163 |
164 | console.log('=> Added tabtab source line in "%s" file', filename);
165 | })
166 | .catch(err => {
167 | console.error('mkdirp ERROR', err);
168 | reject(err);
169 | });
170 | };
171 |
172 | /**
173 | * Writes to SHELL config file adding a new line, but only one, to the SHELL
174 | * config script. This enables tabtab to work for the given SHELL.
175 | *
176 | * @param {Object} options - Options object with
177 | * - location: The SHELL script location (~/.bashrc, ~/.zshrc or
178 | * ~/.config/fish/config.fish)
179 | * - name: The package configured for completion
180 | */
181 | const writeToShellConfig = async ({ location, name }) => {
182 | const scriptname = path.join(
183 | COMPLETION_DIR,
184 | `${TABTAB_SCRIPT_NAME}.${shellExtension()}`
185 | );
186 |
187 | const filename = location;
188 |
189 | // Check if SHELL script already has a line for tabtab
190 | const existing = await checkFilenameForLine(filename, scriptname);
191 | if (existing) {
192 | return console.log('=> Tabtab line already exists in %s file', filename);
193 | }
194 |
195 | return new Promise(
196 | writeLineToFilename({
197 | filename,
198 | scriptname,
199 | name
200 | })
201 | );
202 | };
203 |
204 | /**
205 | * Writes to tabtab internal script that acts as a frontend router for the
206 | * completion mechanism, in the internal ~/.config/tabtab directory. Every
207 | * completion is added to this file.
208 | *
209 | * @param {Object} options - Options object with
210 | * - name: The package configured for completion
211 | */
212 | const writeToTabtabScript = async ({ name }) => {
213 | const filename = path.join(
214 | COMPLETION_DIR,
215 | `${TABTAB_SCRIPT_NAME}.${shellExtension()}`
216 | );
217 |
218 | const scriptname = path.join(COMPLETION_DIR, `${name}.${shellExtension()}`);
219 |
220 | // Check if tabtab completion file already has this line in it
221 | const existing = await checkFilenameForLine(filename, scriptname);
222 | if (existing) {
223 | return console.log('=> Tabtab line already exists in %s file', filename);
224 | }
225 |
226 | return new Promise(writeLineToFilename({ filename, scriptname, name }));
227 | };
228 |
229 | /**
230 | * This writes a new completion script in the internal `~/.config/tabtab`
231 | * directory. Depending on the SHELL used, a different script is created for
232 | * the given SHELL.
233 | *
234 | * @param {Object} options - Options object with
235 | * - name: The package configured for completion
236 | * - completer: The binary that will act as the completer for `name` program
237 | */
238 | const writeToCompletionScript = ({ name, completer }) => {
239 | const filename = untildify(
240 | path.join(COMPLETION_DIR, `${name}.${shellExtension()}`)
241 | );
242 |
243 | const script = scriptFromShell();
244 | debug('Writing completion script to', filename);
245 | debug('with', script);
246 |
247 | return readFile(script, 'utf8')
248 | .then(filecontent =>
249 | filecontent
250 | .replace(/\{pkgname\}/g, name)
251 | .replace(/{completer}/g, completer)
252 | // on Bash on windows, we need to make sure to remove any \r
253 | .replace(/\r?\n/g, '\n')
254 | )
255 | .then(filecontent =>
256 | mkdirp(path.dirname(filename)).then(() =>
257 | writeFile(filename, filecontent)
258 | )
259 | )
260 | .then(() => console.log('=> Wrote completion script to %s file', filename))
261 | .catch(err => console.error('ERROR:', err));
262 | };
263 |
264 | /**
265 | * Top level install method. Does three things:
266 | *
267 | * - Writes to SHELL config file, adding a new line to tabtab internal script.
268 | * - Creates or edit tabtab internal script
269 | * - Creates the actual completion script for this package.
270 | *
271 | * @param {Object} options - Options object with
272 | * - name: The program name to complete
273 | * - completer: The actual program or binary that will act as the completer
274 | * for `name` program. Can be the same.
275 | * - location: The SHELL script config location (~/.bashrc, ~/.zshrc or
276 | * ~/.config/fish/config.fish)
277 | */
278 | const install = async (options = { name: '', completer: '', location: '' }) => {
279 | debug('Install with options', options);
280 | if (!options.name) {
281 | throw new Error('options.name is required');
282 | }
283 |
284 | if (!options.completer) {
285 | throw new Error('options.completer is required');
286 | }
287 |
288 | if (!options.location) {
289 | throw new Error('options.location is required');
290 | }
291 |
292 | await Promise.all([
293 | writeToShellConfig(options),
294 | writeToTabtabScript(options),
295 | writeToCompletionScript(options)
296 | ]).then(() => {
297 | const { location, name } = options;
298 | console.log(`
299 | => Tabtab source line added to ${location} for ${name} package.
300 |
301 | Make sure to reload your SHELL.
302 | `);
303 | });
304 | };
305 |
306 | /**
307 | * Removes the 3 relevant lines from provided filename, based on the package
308 | * name passed in.
309 | *
310 | * @param {String} filename - The filename to operate on
311 | * @param {String} name - The package name to look for
312 | */
313 | const removeLinesFromFilename = async (filename, name) => {
314 | /* eslint-disable no-unused-vars */
315 | debug('Removing lines from %s file, looking for %s package', filename, name);
316 | if (!(await exists(filename))) {
317 | return debug('File %s does not exist', filename);
318 | }
319 |
320 | const filecontent = await readFile(filename, 'utf8');
321 | const lines = filecontent.split(/\r?\n/);
322 |
323 | const sourceLine = isInShellConfig(filename)
324 | ? `# tabtab source for packages`
325 | : `# tabtab source for ${name} package`;
326 |
327 | const hasLine = !!filecontent.match(`${sourceLine}`);
328 | if (!hasLine) {
329 | return debug('File %s does not include the line: %s', filename, sourceLine);
330 | }
331 |
332 | let lineIndex = -1;
333 | const buffer = lines
334 | // Build up the new buffer, removing the 3 lines following the sourceline
335 | .map((line, index) => {
336 | const match = line.match(sourceLine);
337 | if (match) {
338 | lineIndex = index;
339 | } else if (lineIndex + 3 <= index) {
340 | lineIndex = -1;
341 | }
342 |
343 | return lineIndex === -1 ? line : '';
344 | })
345 | // Remove any double empty lines from this file
346 | .map((line, index, array) => {
347 | const next = array[index + 1];
348 | if (line === '' && next === '') {
349 | return;
350 | }
351 |
352 | return line;
353 | })
354 | // Remove any undefined value from there
355 | .filter(line => line !== undefined)
356 | .join('\n')
357 | .trim();
358 |
359 | await writeFile(filename, buffer);
360 | console.log('=> Removed tabtab source lines from %s file', filename);
361 | };
362 |
363 | /**
364 | * Here the idea is to uninstall a given package completion from internal
365 | * tabtab scripts and / or the SHELL config.
366 | *
367 | * It also removes the relevant scripts if no more completion are installed on
368 | * the system.
369 | *
370 | * @param {Object} options - Options object with
371 | * - name: The package name to look for
372 | */
373 | const uninstall = async (options = { name: '' }) => {
374 | debug('Uninstall with options', options);
375 | const { name } = options;
376 |
377 | if (!name) {
378 | throw new Error('Unable to uninstall if options.name is missing');
379 | }
380 |
381 | const completionScript = untildify(
382 | path.join(COMPLETION_DIR, `${name}.${shellExtension()}`)
383 | );
384 |
385 | // First, lets remove the completion script itself
386 | if (await exists(completionScript)) {
387 | await unlink(completionScript);
388 | console.log('=> Removed completion script (%s)', completionScript);
389 | }
390 |
391 | // Then the lines in ~/.config/tabtab/__tabtab.shell
392 | const tabtabScript = untildify(
393 | path.join(COMPLETION_DIR, `${TABTAB_SCRIPT_NAME}.${shellExtension()}`)
394 | );
395 | await removeLinesFromFilename(tabtabScript, name);
396 |
397 | // Then, check if __tabtab.shell is empty, if so remove the last source line in SHELL config
398 | const isEmpty = (await readFile(tabtabScript, 'utf8')).trim() === '';
399 | if (isEmpty) {
400 | const shellScript = locationFromShell();
401 | debug(
402 | 'File %s is empty. Removing source line from %s file',
403 | tabtabScript,
404 | shellScript
405 | );
406 | await removeLinesFromFilename(shellScript, name);
407 | }
408 |
409 | console.log('=> Uninstalled completion for %s package', name);
410 | };
411 |
412 | module.exports = {
413 | install,
414 | uninstall,
415 | checkFilenameForLine,
416 | writeToShellConfig,
417 | writeToTabtabScript,
418 | writeToCompletionScript,
419 | writeLineToFilename
420 | };
421 |
--------------------------------------------------------------------------------
/readme.md:
--------------------------------------------------------------------------------
1 | # tabtab
2 |
3 | [](https://travis-ci.org/mklabs/tabtab)
4 | [](https://coveralls.io/github/mklabs/tabtab?branch=3.0.0)
5 |
6 | A node package to do some custom command line `