├── tslint.json ├── .gitignore ├── .gitmodules ├── screencast.gif ├── keymaps └── keymap.cson ├── styles └── hint-panel.less ├── src ├── atom-config.d.ts ├── config.ts ├── opertator-regex.ts ├── last-suggestion-view.ts ├── autocomplete-haskell.ts └── suggestion-builder.ts ├── coffeelint.json ├── tsconfig.json ├── LICENSE.md ├── package.json ├── lib ├── config.js ├── opertator-regex.js ├── last-suggestion-view.js ├── autocomplete-haskell.js └── suggestion-builder.js ├── README.md └── CHANGELOG.md /tslint.json: -------------------------------------------------------------------------------- 1 | { "extends": "atom-haskell-tslint-rules" } 2 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | .DS_Store 2 | npm-debug.log 3 | node_modules 4 | analyze* 5 | -------------------------------------------------------------------------------- /.gitmodules: -------------------------------------------------------------------------------- 1 | [submodule "typings"] 2 | path = typings 3 | url = git@github.com:atom-haskell/typings.git 4 | -------------------------------------------------------------------------------- /screencast.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/atom-haskell-archive/autocomplete-haskell/HEAD/screencast.gif -------------------------------------------------------------------------------- /keymaps/keymap.cson: -------------------------------------------------------------------------------- 1 | 'atom-text-editor[data-grammar~="haskell"]': 2 | 'escape': 'autocomplete-haskell:conceal-hint-panel' 3 | -------------------------------------------------------------------------------- /styles/hint-panel.less: -------------------------------------------------------------------------------- 1 | autocomplete-haskell-hint { 2 | white-space: pre-wrap; 3 | margin: 0.1em 0.5em; 4 | min-height: 1.2em; 5 | display: block; 6 | } 7 | -------------------------------------------------------------------------------- /src/atom-config.d.ts: -------------------------------------------------------------------------------- 1 | declare namespace AtomTypes { 2 | interface ConfigInterface { 3 | 'autocomplete-haskell.defaultHintPanelVisibility': 'Visible' | 'Hidden' 4 | 'autocomplete-haskell.hideHintPanelIfEmpty': boolean 5 | 'autocomplete-haskell.showIdeHaskellTooltip': boolean 6 | } 7 | } 8 | -------------------------------------------------------------------------------- /src/config.ts: -------------------------------------------------------------------------------- 1 | export const config = { 2 | defaultHintPanelVisibility: { 3 | type: 'string', 4 | default: 'Visible', 5 | enum: ['Visible', 'Hidden'], 6 | }, 7 | hideHintPanelIfEmpty: { 8 | type: 'boolean', 9 | default: true, 10 | description: `\ 11 | Hide hint panel if it's empty. Also enables 'escape' key 12 | to hide it.\ 13 | `, 14 | }, 15 | showIdeHaskellTooltip: { 16 | type: 'boolean', 17 | default: false, 18 | description: `\ 19 | Show ide-haskell tooltip with last completion type\ 20 | `, 21 | }, 22 | } 23 | -------------------------------------------------------------------------------- /src/opertator-regex.ts: -------------------------------------------------------------------------------- 1 | import XRegExp = require('xregexp') 2 | // From language-haskell 3 | const identCharClass = `[\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']` 4 | const classNameOne = `[\\p{Lu}\\p{Lt}]${identCharClass}*` 5 | const className = `${classNameOne}(?:\\.${classNameOne})*` 6 | const modulePrefix = `(?:${className}\\.)?` 7 | const operatorChar = '(?:(?![(),;\\[\\]`{}_"\'])[\\p{S}\\p{P}])' 8 | const operator = `${operatorChar}+` 9 | export const identRx = XRegExp(`(${modulePrefix})(${identCharClass}*)$`, 'u') 10 | export const operatorRx = XRegExp(`(${modulePrefix})(${operator})$`, 'u') 11 | -------------------------------------------------------------------------------- /coffeelint.json: -------------------------------------------------------------------------------- 1 | { 2 | "arrow_spacing": { 3 | "name": "arrow_spacing", 4 | "level": "error" 5 | }, 6 | "ensure_comprehensions": { 7 | "name": "ensure_comprehensions", 8 | "level": "error" 9 | }, 10 | "max_line_length": { 11 | "name": "max_line_length", 12 | "value": 120, 13 | "level": "error", 14 | "limitComments": true 15 | }, 16 | "indentation": { 17 | "name": "indentation", 18 | "value": 2, 19 | "level": "error" 20 | }, 21 | "no_empty_param_list": { 22 | "name": "no_empty_param_list", 23 | "level": "error" 24 | }, 25 | "cyclomatic_complexity": { 26 | "name": "cyclomatic_complexity", 27 | "value": 22, 28 | "level": "error" 29 | }, 30 | "no_unnecessary_fat_arrows": { 31 | "name": "no_unnecessary_fat_arrows", 32 | "level": "error" 33 | }, 34 | "space_operators": { 35 | "name": "space_operators", 36 | "level": "error" 37 | }, 38 | "spacing_after_comma": { 39 | "name": "spacing_after_comma", 40 | "level": "error" 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /tsconfig.json: -------------------------------------------------------------------------------- 1 | { 2 | "compilerOptions": { 3 | "target": "es6", 4 | "module": "commonjs", 5 | "moduleResolution": "node", 6 | "isolatedModules": false, 7 | "jsx": "react", 8 | "experimentalDecorators": true, 9 | "emitDecoratorMetadata": true, 10 | "declaration": false, 11 | "noImplicitAny": true, 12 | "noImplicitUseStrict": false, 13 | "removeComments": true, 14 | "noLib": false, 15 | "jsxFactory": "etch.dom", 16 | "preserveConstEnums": true, 17 | "suppressImplicitAnyIndexErrors": true, 18 | "outDir": "lib", 19 | "inlineSources": true, 20 | "inlineSourceMap": true, 21 | "strictNullChecks": true, 22 | "allowJs": true, 23 | "lib":["dom","es2017"], 24 | "strict": true 25 | }, 26 | "exclude": [ 27 | "node_modules" 28 | ], 29 | "include": [ 30 | "src/**/*.ts", 31 | "src/**/*.tsx", 32 | "src/**/*.js", 33 | "typings/*.d.ts" 34 | ], 35 | "compileOnSave": true 36 | } 37 | -------------------------------------------------------------------------------- /src/last-suggestion-view.ts: -------------------------------------------------------------------------------- 1 | import { CompositeDisposable } from 'atom' 2 | import highlight = require('atom-highlight') 3 | 4 | export class LastSuggestionView { 5 | public element: HTMLElement 6 | private disposables: CompositeDisposable 7 | constructor(text: string = '') { 8 | this.element = document.createElement('div') 9 | this.disposables = new CompositeDisposable() 10 | this.disposables.add( 11 | atom.config.observe('editor.fontFamily', (val: string) => { 12 | this.element.style.fontFamily = val ? val : '' 13 | }), 14 | atom.config.observe('editor.fontSize', (val: number) => { 15 | this.element.style.fontSize = val ? `${val}px` : '' 16 | }), 17 | ) 18 | this.setText(text) 19 | } 20 | 21 | public destroy() { 22 | this.element.remove() 23 | } 24 | 25 | public setText(text: string) { 26 | this.element.innerHTML = highlight({ 27 | fileContents: text, 28 | scopeName: 'hint.haskell', 29 | nbsp: false, 30 | editorDiv: true, 31 | editorDivTag: 'autocomplete-haskell-hint', 32 | }) 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /LICENSE.md: -------------------------------------------------------------------------------- 1 | Copyright (c) 2015 Atom-Haskell 2 | 3 | Permission is hereby granted, free of charge, to any person obtaining 4 | a copy of this software and associated documentation files (the 5 | "Software"), to deal in the Software without restriction, including 6 | without limitation the rights to use, copy, modify, merge, publish, 7 | distribute, sublicense, and/or sell copies of the Software, and to 8 | permit persons to whom the Software is furnished to do so, subject to 9 | the following conditions: 10 | 11 | The above copyright notice and this permission notice shall be 12 | included in all copies or substantial portions of the Software. 13 | 14 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 15 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 16 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 17 | NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE 18 | LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION 19 | OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION 20 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 21 | -------------------------------------------------------------------------------- /package.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "autocomplete-haskell", 3 | "main": "./lib/autocomplete-haskell", 4 | "version": "1.0.1", 5 | "description": "Autocomplete-plus provider for haskell", 6 | "keywords": [ 7 | "ide-haskell", 8 | "ide", 9 | "haskell", 10 | "autocomplete", 11 | "autocomplete-plus" 12 | ], 13 | "repository": "https://github.com/atom-haskell/autocomplete-haskell", 14 | "license": "MIT", 15 | "engines": { 16 | "atom": ">=1.19.0 <2.0.0" 17 | }, 18 | "activationHooks": [ 19 | "language-haskell:grammar-used" 20 | ], 21 | "dependencies": { 22 | "atom-highlight": "^0.3.0", 23 | "fuzzaldrin": "^2.1.0", 24 | "xregexp": "^3.2.0" 25 | }, 26 | "providedServices": { 27 | "autocomplete.provider": { 28 | "versions": { 29 | "2.0.0": "autocompleteProvider_2_0_0" 30 | } 31 | } 32 | }, 33 | "consumedServices": { 34 | "haskell-completion-backend": { 35 | "versions": { 36 | "0.1.0": "consumeCompBack", 37 | "^1.0.0": "consumeCompBack" 38 | } 39 | }, 40 | "ide-haskell-upi": { 41 | "description": "Uses ide-haskell's unified pluggable interface", 42 | "versions": { 43 | "^0.3.0": "consumeUPI" 44 | } 45 | } 46 | }, 47 | "devDependencies": { 48 | "@types/fuzzaldrin": "^2.1.0", 49 | "@types/xregexp": "^3.0.29", 50 | "atom-haskell-tslint-rules": "0.0.7", 51 | "atom-haskell-utils": "^1.0.0", 52 | "tslint": "^5.6.0", 53 | "typescript": "^2.4.2" 54 | } 55 | } 56 | -------------------------------------------------------------------------------- /lib/config.js: -------------------------------------------------------------------------------- 1 | "use strict"; 2 | Object.defineProperty(exports, "__esModule", { value: true }); 3 | exports.config = { 4 | defaultHintPanelVisibility: { 5 | type: 'string', 6 | default: 'Visible', 7 | enum: ['Visible', 'Hidden'], 8 | }, 9 | hideHintPanelIfEmpty: { 10 | type: 'boolean', 11 | default: true, 12 | description: `\ 13 | Hide hint panel if it's empty. Also enables 'escape' key 14 | to hide it.\ 15 | `, 16 | }, 17 | showIdeHaskellTooltip: { 18 | type: 'boolean', 19 | default: false, 20 | description: `\ 21 | Show ide-haskell tooltip with last completion type\ 22 | `, 23 | }, 24 | }; 25 | //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZmlnLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL2NvbmZpZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUFhLFFBQUEsTUFBTSxHQUFHO0lBQ3BCLDBCQUEwQixFQUFFO1FBQzFCLElBQUksRUFBRSxRQUFRO1FBQ2QsT0FBTyxFQUFFLFNBQVM7UUFDbEIsSUFBSSxFQUFFLENBQUMsU0FBUyxFQUFFLFFBQVEsQ0FBQztLQUM1QjtJQUNELG9CQUFvQixFQUFFO1FBQ3BCLElBQUksRUFBRSxTQUFTO1FBQ2YsT0FBTyxFQUFFLElBQUk7UUFDYixXQUFXLEVBQUU7OztDQUdoQjtLQUNFO0lBQ0QscUJBQXFCLEVBQUU7UUFDckIsSUFBSSxFQUFFLFNBQVM7UUFDZixPQUFPLEVBQUUsS0FBSztRQUNkLFdBQVcsRUFBRTs7Q0FFaEI7S0FDRTtDQUNGLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgY29uc3QgY29uZmlnID0ge1xuICBkZWZhdWx0SGludFBhbmVsVmlzaWJpbGl0eToge1xuICAgIHR5cGU6ICdzdHJpbmcnLFxuICAgIGRlZmF1bHQ6ICdWaXNpYmxlJyxcbiAgICBlbnVtOiBbJ1Zpc2libGUnLCAnSGlkZGVuJ10sXG4gIH0sXG4gIGhpZGVIaW50UGFuZWxJZkVtcHR5OiB7XG4gICAgdHlwZTogJ2Jvb2xlYW4nLFxuICAgIGRlZmF1bHQ6IHRydWUsXG4gICAgZGVzY3JpcHRpb246IGBcXFxuSGlkZSBoaW50IHBhbmVsIGlmIGl0J3MgZW1wdHkuIEFsc28gZW5hYmxlcyAnZXNjYXBlJyBrZXlcbnRvIGhpZGUgaXQuXFxcbmAsXG4gIH0sXG4gIHNob3dJZGVIYXNrZWxsVG9vbHRpcDoge1xuICAgIHR5cGU6ICdib29sZWFuJyxcbiAgICBkZWZhdWx0OiBmYWxzZSxcbiAgICBkZXNjcmlwdGlvbjogYFxcXG5TaG93IGlkZS1oYXNrZWxsIHRvb2x0aXAgd2l0aCBsYXN0IGNvbXBsZXRpb24gdHlwZVxcXG5gLFxuICB9LFxufVxuIl19 -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # autocomplete-haskell atom package ![](https://david-dm.org/atom-haskell/autocomplete-haskell.svg) 2 | 3 | Autocomplete-haskell provides autocompletion facilities for your Haskell 4 | hacking. 5 | It relies on scope names provided by [language-haskell][1] and `haskell-completion-backend` service, provided by [haskell-ghc-mod][2] 6 | 7 | You can show auto-completions for hole `_`. This will try to find replacements 8 | based on type. It's no magic though, so if hole has some crazy type, it won't 9 | find anything. You can also refine hole completions based on name by using named holes, e.g. `_from` 10 | 11 | Current autocompletion scopes: 12 | 13 | * Import module name 14 | * Import module symbols 15 | * Language pragmas 16 | * OPTIONS_GHC pragma 17 | * Type name 18 | * Class name 19 | * Symbol name 20 | 21 | Sadly, it does not pick up types and/or other symbols defined in current file 22 | (ghc-mod seems to be incapable of this feat), so for this you have to rely on 23 | default autocomplete-plus SymbolProvider. 24 | 25 | ## Dependencies 26 | 27 | Atom packages: 28 | 29 | * [language-haskell][1] 30 | * [haskell-ghc-mod][2] 31 | 32 | [1]: https://atom.io/packages/language-haskell 33 | [2]: https://atom.io/packages/haskell-ghc-mod 34 | 35 | Autocompletion: 36 | 37 | ![autocomplete](https://cloud.githubusercontent.com/assets/7275622/9704861/e4474ec4-54bc-11e5-92f4-84a3995e45cb.gif) 38 | 39 | Import autocompletion: 40 | 41 | ![import](https://cloud.githubusercontent.com/assets/7275622/9704865/ff39f79a-54bc-11e5-9912-5fb2884b749b.gif) 42 | 43 | Hole autocompletion: 44 | 45 | ![hole](https://cloud.githubusercontent.com/assets/7275622/9704890/5581ccae-54bd-11e5-8ec6-8aa289e5a099.gif) 46 | 47 | # License 48 | 49 | Copyright © 2015 Atom-Haskell 50 | 51 | Contributors (by number of commits): 52 | 53 | 54 | * Nikolay Yakimov 55 | 56 | 57 | 58 | See the [LICENSE.md][LICENSE] for details. 59 | 60 | [LICENSE]: https://github.com/atom-haskell/autocomplete-haskell/blob/master/LICENSE.md 61 | -------------------------------------------------------------------------------- /lib/opertator-regex.js: -------------------------------------------------------------------------------- 1 | "use strict"; 2 | Object.defineProperty(exports, "__esModule", { value: true }); 3 | const XRegExp = require("xregexp"); 4 | const identCharClass = `[\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']`; 5 | const classNameOne = `[\\p{Lu}\\p{Lt}]${identCharClass}*`; 6 | const className = `${classNameOne}(?:\\.${classNameOne})*`; 7 | const modulePrefix = `(?:${className}\\.)?`; 8 | const operatorChar = '(?:(?![(),;\\[\\]`{}_"\'])[\\p{S}\\p{P}])'; 9 | const operator = `${operatorChar}+`; 10 | exports.identRx = XRegExp(`(${modulePrefix})(${identCharClass}*)$`, 'u'); 11 | exports.operatorRx = XRegExp(`(${modulePrefix})(${operator})$`, 'u'); 12 | //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3BlcnRhdG9yLXJlZ2V4LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL29wZXJ0YXRvci1yZWdleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUFBLG1DQUFtQztBQUVuQyxNQUFNLGNBQWMsR0FBRyxrQ0FBa0MsQ0FBQTtBQUN6RCxNQUFNLFlBQVksR0FBRyxtQkFBbUIsY0FBYyxHQUFHLENBQUE7QUFDekQsTUFBTSxTQUFTLEdBQUcsR0FBRyxZQUFZLFNBQVMsWUFBWSxJQUFJLENBQUE7QUFDMUQsTUFBTSxZQUFZLEdBQUcsTUFBTSxTQUFTLE9BQU8sQ0FBQTtBQUMzQyxNQUFNLFlBQVksR0FBRywyQ0FBMkMsQ0FBQTtBQUNoRSxNQUFNLFFBQVEsR0FBRyxHQUFHLFlBQVksR0FBRyxDQUFBO0FBQ3RCLFFBQUEsT0FBTyxHQUFHLE9BQU8sQ0FBQyxJQUFJLFlBQVksS0FBSyxjQUFjLEtBQUssRUFBRSxHQUFHLENBQUMsQ0FBQTtBQUNoRSxRQUFBLFVBQVUsR0FBRyxPQUFPLENBQUMsSUFBSSxZQUFZLEtBQUssUUFBUSxJQUFJLEVBQUUsR0FBRyxDQUFDLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgWFJlZ0V4cCA9IHJlcXVpcmUoJ3hyZWdleHAnKVxuLy8gRnJvbSBsYW5ndWFnZS1oYXNrZWxsXG5jb25zdCBpZGVudENoYXJDbGFzcyA9IGBbXFxcXHB7TGx9X1xcXFxwe0x1fVxcXFxwe0x0fVxcXFxwe05kfSddYFxuY29uc3QgY2xhc3NOYW1lT25lID0gYFtcXFxccHtMdX1cXFxccHtMdH1dJHtpZGVudENoYXJDbGFzc30qYFxuY29uc3QgY2xhc3NOYW1lID0gYCR7Y2xhc3NOYW1lT25lfSg/OlxcXFwuJHtjbGFzc05hbWVPbmV9KSpgXG5jb25zdCBtb2R1bGVQcmVmaXggPSBgKD86JHtjbGFzc05hbWV9XFxcXC4pP2BcbmNvbnN0IG9wZXJhdG9yQ2hhciA9ICcoPzooPyFbKCksO1xcXFxbXFxcXF1ge31fXCJcXCddKVtcXFxccHtTfVxcXFxwe1B9XSknXG5jb25zdCBvcGVyYXRvciA9IGAke29wZXJhdG9yQ2hhcn0rYFxuZXhwb3J0IGNvbnN0IGlkZW50UnggPSBYUmVnRXhwKGAoJHttb2R1bGVQcmVmaXh9KSgke2lkZW50Q2hhckNsYXNzfSopJGAsICd1JylcbmV4cG9ydCBjb25zdCBvcGVyYXRvclJ4ID0gWFJlZ0V4cChgKCR7bW9kdWxlUHJlZml4fSkoJHtvcGVyYXRvcn0pJGAsICd1JylcbiJdfQ== -------------------------------------------------------------------------------- /CHANGELOG.md: -------------------------------------------------------------------------------- 1 | ## 1.0.1 2 | * Unicode identifiers and operators properly supported via XRegExp 3 | * Parenthesized operators omitted from operator suggestions 4 | 5 | ## 1.0.0 6 | * Suggest operators in completions 7 | * Hide hint panel by default 8 | * Optionally show completion hint as ide-haskell tooltips 9 | * Cleanup & minor fixes 10 | * Rewrite in TypeScript 11 | * Migrate to UPI 0.3 12 | 13 | ## 0.7.2 14 | * Use atom-highlight for completion hint panel 15 | 16 | ## 0.7.1 17 | * Fix keybinding deactivation 18 | 19 | ## 0.7.0 20 | * hideHintPanelIfEmpty, remove old workarounds 21 | * Atom version bump 22 | * Fix LICENSE date 23 | * Update LICENSE 24 | 25 | ## 0.6.7 26 | * Add option for default hint panel visibility 27 | 28 | ## 0.6.6 29 | * Support instance overlap pragmas 30 | 31 | ## 0.6.5 32 | * Fix preprocessorSuggestions 33 | 34 | ## 0.6.4 35 | * Updates for ac-p 2.25 and bugfixes 36 | * 'ingoreMinimumWordLengthForHoleCompletions' option to control hole completions on keystroke. 37 | 38 | ## 0.6.3 39 | * Match type scope on meta.type-signature.haskell 40 | * Add package keywords 41 | 42 | ## 0.6.2 43 | * Delayed hint panel grammar setting, use hint grammar 44 | 45 | ## 0.6.1 46 | * Activate autocomplete-haskell only on Haskell files 47 | 48 | ## 0.6.0 49 | * Add a panel with last completion hint (https://github.com/atom-haskell/ide-haskell/issues/99) 50 | 51 | ## 0.5.1 52 | * Screencasts update 53 | 54 | ## 0.5.0 55 | * Allow for hole completion refinement 56 | 57 | ## 0.4.5 58 | * Support for haskell-ghc-mod 0.8.0 59 | 60 | ## 0.4.4 61 | * Bail on completion if no backend 62 | 63 | ## 0.4.3 64 | * Deactivation fix 65 | 66 | ## 0.4.2 67 | * Set inclusionPriority=0 68 | 69 | ## 0.4.1 70 | * atom-backend-helper version bump 71 | 72 | ## 0.4.0 73 | * Use haskell-completion-backend service 74 | * Add message on multiple backends and none selected 75 | * Possible undefined symbol module 76 | * Remove dep on underscore-plus 77 | * Specify atom version according to docs 78 | * Specify package versions 79 | * Add info on haskell-completion-backend service 80 | * Use fuzzaldrin 81 | * Added pragma words, general overhaul 82 | * Cleanup, array scopes, support for exportsScope 83 | 84 | ## 0.3.1 85 | * Fix deprecated ac+ blacklist option 86 | 87 | ## 0.3.0 88 | * Updated to work with newest haskell-ghc-mod 89 | * Hole completions no longer depend on Hoogle 90 | * Autocomplete+ API 2.0 91 | * Changed EditorController to BufferController 92 | 93 | ## 0.2.1 94 | * BUGFIX: activation problems 95 | 96 | ## 0.2.0 97 | * Migrate to new json-based service provider 98 | * Move out provider code to sep. file 99 | * Bump atom version 100 | 101 | ## 0.1.2 102 | * Fix typo 103 | * A little refactoring 104 | 105 | ## 0.1.1 106 | * Use atom.services.consume once and pass reference around 107 | 108 | ## 0.1.0 - First Release 109 | * Initial release 110 | -------------------------------------------------------------------------------- /lib/last-suggestion-view.js: -------------------------------------------------------------------------------- 1 | "use strict"; 2 | Object.defineProperty(exports, "__esModule", { value: true }); 3 | const atom_1 = require("atom"); 4 | const highlight = require("atom-highlight"); 5 | class LastSuggestionView { 6 | constructor(text = '') { 7 | this.element = document.createElement('div'); 8 | this.disposables = new atom_1.CompositeDisposable(); 9 | this.disposables.add(atom.config.observe('editor.fontFamily', (val) => { 10 | this.element.style.fontFamily = val ? val : ''; 11 | }), atom.config.observe('editor.fontSize', (val) => { 12 | this.element.style.fontSize = val ? `${val}px` : ''; 13 | })); 14 | this.setText(text); 15 | } 16 | destroy() { 17 | this.element.remove(); 18 | } 19 | setText(text) { 20 | this.element.innerHTML = highlight({ 21 | fileContents: text, 22 | scopeName: 'hint.haskell', 23 | nbsp: false, 24 | editorDiv: true, 25 | editorDivTag: 'autocomplete-haskell-hint', 26 | }); 27 | } 28 | } 29 | exports.LastSuggestionView = LastSuggestionView; 30 | //# sourceMappingURL=data:application/json;base64,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 -------------------------------------------------------------------------------- /src/autocomplete-haskell.ts: -------------------------------------------------------------------------------- 1 | import { IEventDesc, CompositeDisposable, Disposable } from 'atom' 2 | import { SuggestionBuilder, IOptions, ISuggestion } from './suggestion-builder' 3 | import { LastSuggestionView } from './last-suggestion-view' 4 | 5 | let backend: UPI.CompletionBackend.ICompletionBackend | undefined 6 | let disposables: CompositeDisposable | undefined 7 | let panel: AtomTypes.Panel | undefined 8 | let upi: UPI.IUPIInstance | undefined 9 | let lastCompletionDesc: string | undefined 10 | 11 | interface IState { 12 | panelVisible?: boolean 13 | lastCompletionDesc: string | undefined 14 | } 15 | 16 | interface IACPDidInsertEventParams { 17 | editor: AtomTypes.TextEditor 18 | triggerPosition: AtomTypes.Point 19 | suggestion: ISuggestion 20 | } 21 | 22 | export { config } from './config' 23 | 24 | export function activate(state: IState) { 25 | disposables = new CompositeDisposable() 26 | 27 | if (state.panelVisible === undefined) { 28 | state.panelVisible = (atom.config.get('autocomplete-haskell.defaultHintPanelVisibility') === 'Visible') 29 | } 30 | 31 | lastCompletionDesc = state.lastCompletionDesc 32 | 33 | if (state.panelVisible) { 34 | createPanel() 35 | } 36 | 37 | disposables.add(atom.config.observe('autocomplete-haskell.hideHintPanelIfEmpty', (val) => { 38 | if (panel) { 39 | !val || lastCompletionDesc ? panel.show() : panel.hide() 40 | } 41 | })) 42 | 43 | disposables.add( 44 | atom.commands.add('atom-text-editor[data-grammar~="haskell"]', { 45 | 'autocomplete-haskell:conceal-hint-panel': ({ currentTarget, abortKeyBinding }: IEventDesc) => { 46 | if (panel && panel.isVisible() && atom.config.get('autocomplete-haskell.hideHintPanelIfEmpty')) { 47 | panel.hide() 48 | } else { 49 | if (typeof abortKeyBinding === 'function') { 50 | abortKeyBinding() 51 | } 52 | } 53 | }, 54 | }, 55 | ), 56 | ) 57 | 58 | disposables.add(atom.commands.add('atom-workspace', { 59 | 'autocomplete-haskell:toggle-completion-hint': () => { 60 | if (panel) { 61 | destroyPanel() 62 | } else { 63 | createPanel() 64 | } 65 | }, 66 | }, 67 | ), 68 | ) 69 | 70 | disposables.add(atom.menu.add([{ 71 | label: 'Haskell IDE', 72 | submenu: [{ 73 | label: 'Toggle Completion Hint Panel', 74 | command: 'autocomplete-haskell:toggle-completion-hint', 75 | }], 76 | }])) 77 | } 78 | 79 | export function serialize(): IState { 80 | return { 81 | panelVisible: !!panel, 82 | lastCompletionDesc, 83 | } 84 | } 85 | 86 | export function deactivate() { 87 | disposables && disposables.dispose() 88 | disposables = undefined 89 | upi = undefined 90 | destroyPanel() 91 | } 92 | 93 | function createPanel() { 94 | panel = atom.workspace.addBottomPanel({ 95 | item: new LastSuggestionView(lastCompletionDesc), 96 | visible: true, 97 | priority: 200, 98 | }) 99 | } 100 | 101 | function destroyPanel() { 102 | panel && panel.destroy() 103 | panel = undefined 104 | } 105 | 106 | export function autocompleteProvider_2_0_0() { 107 | return { 108 | selector: '.source.haskell', 109 | disableForSelector: '.source.haskell .comment', 110 | inclusionPriority: 0, 111 | getSuggestions: (options: IOptions) => { 112 | if (!backend) { return [] } 113 | return (new SuggestionBuilder(options, backend)).getSuggestions() 114 | }, 115 | onDidInsertSuggestion: ({ editor, triggerPosition, suggestion }: IACPDidInsertEventParams) => { 116 | if (suggestion && suggestion.description) { 117 | const desc = lastCompletionDesc = suggestion.description 118 | if (panel) { 119 | const view: LastSuggestionView = panel.getItem() 120 | view.setText(desc) 121 | if (atom.config.get('autocomplete-haskell.hideHintPanelIfEmpty')) { 122 | panel.show() 123 | } 124 | } 125 | if (upi && atom.config.get('autocomplete-haskell.showIdeHaskellTooltip')) { 126 | const p2 = editor.getLastCursor().getBufferPosition() 127 | const p1 = p2.translate([0, -suggestion.text.length]) 128 | setImmediate(() => { 129 | upi && upi.showTooltip({ 130 | editor, 131 | eventType: UPI.TEventRangeType.keyboard, 132 | tooltip: { 133 | range: [p1, p2], 134 | persistent: true, 135 | text: { 136 | text: desc, 137 | highlighter: 'hint.haskell', 138 | }, 139 | }, 140 | }) 141 | }) 142 | } 143 | } else if (panel) { 144 | const view: LastSuggestionView = panel.getItem() 145 | view.setText('') 146 | if (panel && atom.config.get('autocomplete-haskell.hideHintPanelIfEmpty')) { 147 | panel.hide() 148 | } 149 | } 150 | }, 151 | } 152 | } 153 | 154 | export function consumeUPI(service: UPI.IUPIRegistration) { 155 | upi = service({ 156 | name: 'autocomplete-haskell', 157 | }) 158 | disposables && disposables.add(upi) 159 | return upi 160 | } 161 | 162 | export function consumeCompBack(service: UPI.CompletionBackend.ICompletionBackend) { 163 | backend = service 164 | const mydisp = new CompositeDisposable() 165 | disposables && disposables.add(mydisp) 166 | mydisp.add( 167 | atom.workspace.observeTextEditors((editor) => { 168 | if (editor.getGrammar().scopeName === 'source.haskell') { 169 | mydisp.add(service.registerCompletionBuffer(editor.getBuffer())) 170 | } 171 | }), 172 | new Disposable(() => { 173 | backend = undefined 174 | disposables && disposables.remove(mydisp) 175 | }), 176 | ) 177 | return mydisp 178 | } 179 | -------------------------------------------------------------------------------- /src/suggestion-builder.ts: -------------------------------------------------------------------------------- 1 | import { Range } from 'atom' 2 | import { filter } from 'fuzzaldrin' 3 | import CB = UPI.CompletionBackend 4 | 5 | const typeScope = ['meta.type-signature.haskell'] 6 | const sourceScope = ['source.haskell'] 7 | const moduleScope = ['meta.import.haskell', 'support.other.module.haskell'] 8 | const preprocessorScope = ['meta.preprocessor.haskell'] 9 | const instancePreprocessorScope = ['meta.declaration.instance.haskell', 'meta.preprocessor.haskell'] 10 | const exportsScope = ['meta.import.haskell', 'meta.declaration.exports.haskell'] 11 | 12 | const pragmaWords = [ 13 | 'LANGUAGE', 'OPTIONS_GHC', 'INCLUDE', 'WARNING', 'DEPRECATED', 'INLINE', 14 | 'NOINLINE', 'ANN', 'LINE', 'RULES', 'SPECIALIZE', 'UNPACK', 'SOURCE', 15 | ] 16 | 17 | const instancePragmaWords = [ 18 | 'INCOHERENT', 19 | 'OVERLAPPABLE', 20 | 'OVERLAPPING', 21 | 'OVERLAPS', 22 | ] 23 | 24 | import { operatorRx, identRx } from './opertator-regex' 25 | 26 | export interface IOptions { 27 | editor: AtomTypes.TextEditor 28 | bufferPosition: AtomTypes.Point 29 | activatedManually: boolean 30 | scopeDescriptor: AtomTypes.ScopeDescriptor 31 | } 32 | 33 | export interface ISuggestion { 34 | text: string 35 | rightLabel?: string 36 | type: CB.SymbolType | 'import' | 'keyword' 37 | replacementPrefix: string 38 | description?: string 39 | } 40 | 41 | type GetSymbolsCallback = (buffer: AtomTypes.TextBuffer, prefix: string, position: AtomTypes.Point) => Promise 42 | 43 | export class SuggestionBuilder { 44 | private buffer: AtomTypes.TextBuffer 45 | private lineRange: AtomTypes.Range 46 | private line: string 47 | private mwl: number 48 | constructor(private options: IOptions, private backend: CB.ICompletionBackend) { 49 | this.buffer = this.options.editor.getBuffer() 50 | this.lineRange = new Range( 51 | [this.options.bufferPosition.row, 0], 52 | this.options.bufferPosition, 53 | ) 54 | this.line = this.buffer.getTextInRange(this.lineRange) 55 | this.mwl = 56 | this.options.activatedManually ? 57 | 0 58 | : 59 | atom.config.get('autocomplete-plus.minimumWordLength') 60 | } 61 | 62 | public async getSuggestions(): Promise { 63 | if (this.isIn(instancePreprocessorScope)) { 64 | return this.preprocessorSuggestions(instancePragmaWords) 65 | } else if (this.isIn(typeScope)) { 66 | return this.symbolSuggestions(this.backend.getCompletionsForType.bind(this.backend)) 67 | } else if (this.isIn(moduleScope)) { 68 | return this.moduleSuggestions() 69 | } else if (this.isIn(exportsScope)) { 70 | return this.symbolSuggestions(this.backend.getCompletionsForSymbolInModule.bind(this.backend)) 71 | } else if (this.isIn(preprocessorScope)) { 72 | return this.preprocessorSuggestions(pragmaWords) 73 | // should be last as least sepcialized 74 | } else if (this.isIn(sourceScope)) { 75 | if (this.getPrefix().startsWith('_')) { 76 | return this.symbolSuggestions(this.backend.getCompletionsForHole.bind(this.backend)) 77 | } else if (this.getPrefix() === '' && this.getPrefix(operatorRx) !== '') { 78 | return this.operatorSuggestions() 79 | } else { 80 | return this.symbolSuggestions(this.backend.getCompletionsForSymbol.bind(this.backend)) 81 | } 82 | } else { 83 | return [] 84 | } 85 | } 86 | 87 | private lineSearch(rx: RegExp, idx: number = 0) { 88 | const match = this.line.match(rx) 89 | if (match) { 90 | return match 91 | } else { 92 | return [''] 93 | } 94 | } 95 | 96 | private isIn(scope: string[]) { 97 | return scope.every((s1) => this.options.scopeDescriptor.getScopesArray().includes(s1)) 98 | } 99 | 100 | private getPrefix(rx?: RegExp) { 101 | if (!rx) { rx = identRx } 102 | return this.lineSearch(rx)[0] 103 | } 104 | 105 | private buildSymbolSuggestion(s: CB.ISymbol, prefix: string): ISuggestion { 106 | return { 107 | text: s.qname ? s.qname : s.name, 108 | rightLabel: (s.module ? s.module.name : undefined), 109 | type: s.symbolType, 110 | replacementPrefix: prefix, 111 | description: this.nameFix(s) + ' :: ' + s.typeSignature, 112 | } 113 | } 114 | 115 | private nameFix(s: CB.ISymbol) { 116 | if (s.symbolType === 'operator') { 117 | return `(${s.name})` 118 | } else { 119 | return s.name 120 | } 121 | } 122 | 123 | private buildSimpleSuggestion( 124 | type: 'import' | 'keyword', text: string, prefix: string, label?: string, 125 | ): ISuggestion { 126 | return { 127 | text, 128 | type, 129 | replacementPrefix: prefix, 130 | rightLabel: label, 131 | } 132 | } 133 | 134 | private async processSuggestions( 135 | f: GetSymbolsCallback, rx: RegExp | undefined, p: (s: T, p: string) => ISuggestion, 136 | ) { 137 | const prefix = this.getPrefix(rx) 138 | if (prefix.length < this.mwl) { 139 | return [] 140 | } 141 | const symbols = await f(this.buffer, prefix, this.options.bufferPosition) 142 | return symbols.map((s) => p(s, prefix)) 143 | } 144 | 145 | private async symbolSuggestions(f: GetSymbolsCallback, rx?: RegExp) { 146 | return this.processSuggestions(f, rx, this.buildSymbolSuggestion.bind(this)) 147 | } 148 | 149 | private async moduleSuggestions() { 150 | return this.processSuggestions(this.backend.getCompletionsForModule.bind(this.backend), undefined, (s, prefix) => 151 | this.buildSimpleSuggestion('import', s, prefix)) 152 | } 153 | 154 | private preprocessorSuggestions(pragmaList: string[]) { 155 | let f: GetSymbolsCallback 156 | const kwrx = new RegExp(`\\b(${pragmaList.join('|')})\\b`) 157 | const kw = this.lineSearch(kwrx)[0] 158 | let label = '' 159 | let rx 160 | switch (false) { 161 | case kw !== 'OPTIONS_GHC': 162 | rx = /[\w-]+$/ 163 | label = 'GHC Flag' 164 | f = this.backend.getCompletionsForCompilerOptions 165 | break 166 | case kw !== 'LANGUAGE': 167 | label = 'Language' 168 | f = this.backend.getCompletionsForLanguagePragmas 169 | break 170 | case !!kw: 171 | label = 'Pragma' 172 | f = async (b, p) => filter(pragmaList, p) 173 | break 174 | default: 175 | return [] 176 | } 177 | 178 | return this.processSuggestions(f, rx, (s, prefix) => 179 | this.buildSimpleSuggestion('keyword', s, prefix, label)) 180 | } 181 | 182 | private async operatorSuggestions() { 183 | const prefixMatch = this.lineSearch(operatorRx) 184 | if (!prefixMatch) { return [] } 185 | const [mod, op] = prefixMatch.slice(1) 186 | if (prefixMatch[0].length < this.mwl) { 187 | return [] 188 | } 189 | const symbols = 190 | await this.backend.getCompletionsForSymbol(this.buffer, `${mod || ''}${op}`, this.options.bufferPosition) 191 | const newSyms = 192 | symbols 193 | .filter(({ symbolType }) => symbolType === 'operator') 194 | const allSyms = filter(newSyms, prefixMatch[0], { key: 'qname' }) 195 | return allSyms.map((s) => this.buildSymbolSuggestion(s, prefixMatch[0])) 196 | } 197 | } 198 | -------------------------------------------------------------------------------- /lib/autocomplete-haskell.js: -------------------------------------------------------------------------------- 1 | "use strict"; 2 | Object.defineProperty(exports, "__esModule", { value: true }); 3 | const atom_1 = require("atom"); 4 | const suggestion_builder_1 = require("./suggestion-builder"); 5 | const last_suggestion_view_1 = require("./last-suggestion-view"); 6 | let backend; 7 | let disposables; 8 | let panel; 9 | let upi; 10 | let lastCompletionDesc; 11 | var config_1 = require("./config"); 12 | exports.config = config_1.config; 13 | function activate(state) { 14 | disposables = new atom_1.CompositeDisposable(); 15 | if (state.panelVisible === undefined) { 16 | state.panelVisible = (atom.config.get('autocomplete-haskell.defaultHintPanelVisibility') === 'Visible'); 17 | } 18 | lastCompletionDesc = state.lastCompletionDesc; 19 | if (state.panelVisible) { 20 | createPanel(); 21 | } 22 | disposables.add(atom.config.observe('autocomplete-haskell.hideHintPanelIfEmpty', (val) => { 23 | if (panel) { 24 | !val || lastCompletionDesc ? panel.show() : panel.hide(); 25 | } 26 | })); 27 | disposables.add(atom.commands.add('atom-text-editor[data-grammar~="haskell"]', { 28 | 'autocomplete-haskell:conceal-hint-panel': ({ currentTarget, abortKeyBinding }) => { 29 | if (panel && panel.isVisible() && atom.config.get('autocomplete-haskell.hideHintPanelIfEmpty')) { 30 | panel.hide(); 31 | } 32 | else { 33 | if (typeof abortKeyBinding === 'function') { 34 | abortKeyBinding(); 35 | } 36 | } 37 | }, 38 | })); 39 | disposables.add(atom.commands.add('atom-workspace', { 40 | 'autocomplete-haskell:toggle-completion-hint': () => { 41 | if (panel) { 42 | destroyPanel(); 43 | } 44 | else { 45 | createPanel(); 46 | } 47 | }, 48 | })); 49 | disposables.add(atom.menu.add([{ 50 | label: 'Haskell IDE', 51 | submenu: [{ 52 | label: 'Toggle Completion Hint Panel', 53 | command: 'autocomplete-haskell:toggle-completion-hint', 54 | }], 55 | }])); 56 | } 57 | exports.activate = activate; 58 | function serialize() { 59 | return { 60 | panelVisible: !!panel, 61 | lastCompletionDesc, 62 | }; 63 | } 64 | exports.serialize = serialize; 65 | function deactivate() { 66 | disposables && disposables.dispose(); 67 | disposables = undefined; 68 | upi = undefined; 69 | destroyPanel(); 70 | } 71 | exports.deactivate = deactivate; 72 | function createPanel() { 73 | panel = atom.workspace.addBottomPanel({ 74 | item: new last_suggestion_view_1.LastSuggestionView(lastCompletionDesc), 75 | visible: true, 76 | priority: 200, 77 | }); 78 | } 79 | function destroyPanel() { 80 | panel && panel.destroy(); 81 | panel = undefined; 82 | } 83 | function autocompleteProvider_2_0_0() { 84 | return { 85 | selector: '.source.haskell', 86 | disableForSelector: '.source.haskell .comment', 87 | inclusionPriority: 0, 88 | getSuggestions: (options) => { 89 | if (!backend) { 90 | return []; 91 | } 92 | return (new suggestion_builder_1.SuggestionBuilder(options, backend)).getSuggestions(); 93 | }, 94 | onDidInsertSuggestion: ({ editor, triggerPosition, suggestion }) => { 95 | if (suggestion && suggestion.description) { 96 | const desc = lastCompletionDesc = suggestion.description; 97 | if (panel) { 98 | const view = panel.getItem(); 99 | view.setText(desc); 100 | if (atom.config.get('autocomplete-haskell.hideHintPanelIfEmpty')) { 101 | panel.show(); 102 | } 103 | } 104 | if (upi && atom.config.get('autocomplete-haskell.showIdeHaskellTooltip')) { 105 | const p2 = editor.getLastCursor().getBufferPosition(); 106 | const p1 = p2.translate([0, -suggestion.text.length]); 107 | setImmediate(() => { 108 | upi && upi.showTooltip({ 109 | editor, 110 | eventType: "keyboard", 111 | tooltip: { 112 | range: [p1, p2], 113 | persistent: true, 114 | text: { 115 | text: desc, 116 | highlighter: 'hint.haskell', 117 | }, 118 | }, 119 | }); 120 | }); 121 | } 122 | } 123 | else if (panel) { 124 | const view = panel.getItem(); 125 | view.setText(''); 126 | if (panel && atom.config.get('autocomplete-haskell.hideHintPanelIfEmpty')) { 127 | panel.hide(); 128 | } 129 | } 130 | }, 131 | }; 132 | } 133 | exports.autocompleteProvider_2_0_0 = autocompleteProvider_2_0_0; 134 | function consumeUPI(service) { 135 | upi = service({ 136 | name: 'autocomplete-haskell', 137 | }); 138 | disposables && disposables.add(upi); 139 | return upi; 140 | } 141 | exports.consumeUPI = consumeUPI; 142 | function consumeCompBack(service) { 143 | backend = service; 144 | const mydisp = new atom_1.CompositeDisposable(); 145 | disposables && disposables.add(mydisp); 146 | mydisp.add(atom.workspace.observeTextEditors((editor) => { 147 | if (editor.getGrammar().scopeName === 'source.haskell') { 148 | mydisp.add(service.registerCompletionBuffer(editor.getBuffer())); 149 | } 150 | }), new atom_1.Disposable(() => { 151 | backend = undefined; 152 | disposables && disposables.remove(mydisp); 153 | })); 154 | return mydisp; 155 | } 156 | exports.consumeCompBack = consumeCompBack; 157 | //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"autocomplete-haskell.js","sourceRoot":"","sources":["../src/autocomplete-haskell.ts"],"names":[],"mappings":"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","sourcesContent":["import { IEventDesc, CompositeDisposable, Disposable } from 'atom'\nimport { SuggestionBuilder, IOptions, ISuggestion } from './suggestion-builder'\nimport { LastSuggestionView } from './last-suggestion-view'\n\nlet backend: UPI.CompletionBackend.ICompletionBackend | undefined\nlet disposables: CompositeDisposable | undefined\nlet panel: AtomTypes.Panel<LastSuggestionView> | undefined\nlet upi: UPI.IUPIInstance | undefined\nlet lastCompletionDesc: string | undefined\n\ninterface IState {\n  panelVisible?: boolean\n  lastCompletionDesc: string | undefined\n}\n\ninterface IACPDidInsertEventParams {\n  editor: AtomTypes.TextEditor\n  triggerPosition: AtomTypes.Point\n  suggestion: ISuggestion\n}\n\nexport { config } from './config'\n\nexport function activate(state: IState) {\n  disposables = new CompositeDisposable()\n\n  if (state.panelVisible === undefined) {\n    state.panelVisible = (atom.config.get('autocomplete-haskell.defaultHintPanelVisibility') === 'Visible')\n  }\n\n  lastCompletionDesc = state.lastCompletionDesc\n\n  if (state.panelVisible) {\n    createPanel()\n  }\n\n  disposables.add(atom.config.observe('autocomplete-haskell.hideHintPanelIfEmpty', (val) => {\n    if (panel) {\n      !val || lastCompletionDesc ? panel.show() : panel.hide()\n    }\n  }))\n\n  disposables.add(\n    atom.commands.add('atom-text-editor[data-grammar~=\"haskell\"]', {\n      'autocomplete-haskell:conceal-hint-panel': ({ currentTarget, abortKeyBinding }: IEventDesc) => {\n        if (panel && panel.isVisible() && atom.config.get('autocomplete-haskell.hideHintPanelIfEmpty')) {\n          panel.hide()\n        } else {\n          if (typeof abortKeyBinding === 'function') {\n            abortKeyBinding()\n          }\n        }\n      },\n    },\n  ),\n  )\n\n  disposables.add(atom.commands.add('atom-workspace', {\n    'autocomplete-haskell:toggle-completion-hint': () => {\n      if (panel) {\n        destroyPanel()\n      } else {\n        createPanel()\n      }\n    },\n  },\n),\n  )\n\n  disposables.add(atom.menu.add([{\n    label: 'Haskell IDE',\n    submenu: [{\n      label: 'Toggle Completion Hint Panel',\n      command: 'autocomplete-haskell:toggle-completion-hint',\n    }],\n  }]))\n}\n\nexport function serialize(): IState {\n  return {\n    panelVisible: !!panel,\n    lastCompletionDesc,\n  }\n}\n\nexport function deactivate() {\n  disposables && disposables.dispose()\n  disposables = undefined\n  upi = undefined\n  destroyPanel()\n}\n\nfunction createPanel() {\n  panel = atom.workspace.addBottomPanel({\n    item: new LastSuggestionView(lastCompletionDesc),\n    visible: true,\n    priority: 200,\n  })\n}\n\nfunction destroyPanel() {\n  panel && panel.destroy()\n  panel = undefined\n}\n\nexport function autocompleteProvider_2_0_0() {\n  return {\n    selector: '.source.haskell',\n    disableForSelector: '.source.haskell .comment',\n    inclusionPriority: 0,\n    getSuggestions: (options: IOptions) => {\n      if (!backend) { return [] }\n      return (new SuggestionBuilder(options, backend)).getSuggestions()\n    },\n    onDidInsertSuggestion: ({ editor, triggerPosition, suggestion }: IACPDidInsertEventParams) => {\n      if (suggestion && suggestion.description) {\n        const desc = lastCompletionDesc = suggestion.description\n        if (panel) {\n          const view: LastSuggestionView = panel.getItem()\n          view.setText(desc)\n          if (atom.config.get('autocomplete-haskell.hideHintPanelIfEmpty')) {\n            panel.show()\n          }\n        }\n        if (upi && atom.config.get('autocomplete-haskell.showIdeHaskellTooltip')) {\n          const p2 = editor.getLastCursor().getBufferPosition()\n          const p1 = p2.translate([0, -suggestion.text.length])\n          setImmediate(() => {\n            upi && upi.showTooltip({\n              editor,\n              eventType: UPI.TEventRangeType.keyboard,\n              tooltip: {\n                range: [p1, p2],\n                persistent: true,\n                text: {\n                  text: desc,\n                  highlighter: 'hint.haskell',\n                },\n              },\n            })\n          })\n        }\n      } else if (panel) {\n        const view: LastSuggestionView = panel.getItem()\n        view.setText('')\n        if (panel && atom.config.get('autocomplete-haskell.hideHintPanelIfEmpty')) {\n          panel.hide()\n        }\n      }\n    },\n  }\n}\n\nexport function consumeUPI(service: UPI.IUPIRegistration) {\n  upi = service({\n    name: 'autocomplete-haskell',\n  })\n  disposables && disposables.add(upi)\n  return upi\n}\n\nexport function consumeCompBack(service: UPI.CompletionBackend.ICompletionBackend) {\n  backend = service\n  const mydisp = new CompositeDisposable()\n  disposables && disposables.add(mydisp)\n  mydisp.add(\n    atom.workspace.observeTextEditors((editor) => {\n      if (editor.getGrammar().scopeName === 'source.haskell') {\n        mydisp.add(service.registerCompletionBuffer(editor.getBuffer()))\n      }\n    }),\n    new Disposable(() => {\n      backend = undefined\n      disposables && disposables.remove(mydisp)\n    }),\n  )\n  return mydisp\n}\n"]} -------------------------------------------------------------------------------- /lib/suggestion-builder.js: -------------------------------------------------------------------------------- 1 | "use strict"; 2 | var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { 3 | return new (P || (P = Promise))(function (resolve, reject) { 4 | function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } 5 | function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } 6 | function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } 7 | step((generator = generator.apply(thisArg, _arguments || [])).next()); 8 | }); 9 | }; 10 | Object.defineProperty(exports, "__esModule", { value: true }); 11 | const atom_1 = require("atom"); 12 | const fuzzaldrin_1 = require("fuzzaldrin"); 13 | const typeScope = ['meta.type-signature.haskell']; 14 | const sourceScope = ['source.haskell']; 15 | const moduleScope = ['meta.import.haskell', 'support.other.module.haskell']; 16 | const preprocessorScope = ['meta.preprocessor.haskell']; 17 | const instancePreprocessorScope = ['meta.declaration.instance.haskell', 'meta.preprocessor.haskell']; 18 | const exportsScope = ['meta.import.haskell', 'meta.declaration.exports.haskell']; 19 | const pragmaWords = [ 20 | 'LANGUAGE', 'OPTIONS_GHC', 'INCLUDE', 'WARNING', 'DEPRECATED', 'INLINE', 21 | 'NOINLINE', 'ANN', 'LINE', 'RULES', 'SPECIALIZE', 'UNPACK', 'SOURCE', 22 | ]; 23 | const instancePragmaWords = [ 24 | 'INCOHERENT', 25 | 'OVERLAPPABLE', 26 | 'OVERLAPPING', 27 | 'OVERLAPS', 28 | ]; 29 | const opertator_regex_1 = require("./opertator-regex"); 30 | class SuggestionBuilder { 31 | constructor(options, backend) { 32 | this.options = options; 33 | this.backend = backend; 34 | this.buffer = this.options.editor.getBuffer(); 35 | this.lineRange = new atom_1.Range([this.options.bufferPosition.row, 0], this.options.bufferPosition); 36 | this.line = this.buffer.getTextInRange(this.lineRange); 37 | this.mwl = 38 | this.options.activatedManually ? 39 | 0 40 | : 41 | atom.config.get('autocomplete-plus.minimumWordLength'); 42 | } 43 | getSuggestions() { 44 | return __awaiter(this, void 0, void 0, function* () { 45 | if (this.isIn(instancePreprocessorScope)) { 46 | return this.preprocessorSuggestions(instancePragmaWords); 47 | } 48 | else if (this.isIn(typeScope)) { 49 | return this.symbolSuggestions(this.backend.getCompletionsForType.bind(this.backend)); 50 | } 51 | else if (this.isIn(moduleScope)) { 52 | return this.moduleSuggestions(); 53 | } 54 | else if (this.isIn(exportsScope)) { 55 | return this.symbolSuggestions(this.backend.getCompletionsForSymbolInModule.bind(this.backend)); 56 | } 57 | else if (this.isIn(preprocessorScope)) { 58 | return this.preprocessorSuggestions(pragmaWords); 59 | } 60 | else if (this.isIn(sourceScope)) { 61 | if (this.getPrefix().startsWith('_')) { 62 | return this.symbolSuggestions(this.backend.getCompletionsForHole.bind(this.backend)); 63 | } 64 | else if (this.getPrefix() === '' && this.getPrefix(opertator_regex_1.operatorRx) !== '') { 65 | return this.operatorSuggestions(); 66 | } 67 | else { 68 | return this.symbolSuggestions(this.backend.getCompletionsForSymbol.bind(this.backend)); 69 | } 70 | } 71 | else { 72 | return []; 73 | } 74 | }); 75 | } 76 | lineSearch(rx, idx = 0) { 77 | const match = this.line.match(rx); 78 | if (match) { 79 | return match; 80 | } 81 | else { 82 | return ['']; 83 | } 84 | } 85 | isIn(scope) { 86 | return scope.every((s1) => this.options.scopeDescriptor.getScopesArray().includes(s1)); 87 | } 88 | getPrefix(rx) { 89 | if (!rx) { 90 | rx = opertator_regex_1.identRx; 91 | } 92 | return this.lineSearch(rx)[0]; 93 | } 94 | buildSymbolSuggestion(s, prefix) { 95 | return { 96 | text: s.qname ? s.qname : s.name, 97 | rightLabel: (s.module ? s.module.name : undefined), 98 | type: s.symbolType, 99 | replacementPrefix: prefix, 100 | description: this.nameFix(s) + ' :: ' + s.typeSignature, 101 | }; 102 | } 103 | nameFix(s) { 104 | if (s.symbolType === 'operator') { 105 | return `(${s.name})`; 106 | } 107 | else { 108 | return s.name; 109 | } 110 | } 111 | buildSimpleSuggestion(type, text, prefix, label) { 112 | return { 113 | text, 114 | type, 115 | replacementPrefix: prefix, 116 | rightLabel: label, 117 | }; 118 | } 119 | processSuggestions(f, rx, p) { 120 | return __awaiter(this, void 0, void 0, function* () { 121 | const prefix = this.getPrefix(rx); 122 | if (prefix.length < this.mwl) { 123 | return []; 124 | } 125 | const symbols = yield f(this.buffer, prefix, this.options.bufferPosition); 126 | return symbols.map((s) => p(s, prefix)); 127 | }); 128 | } 129 | symbolSuggestions(f, rx) { 130 | return __awaiter(this, void 0, void 0, function* () { 131 | return this.processSuggestions(f, rx, this.buildSymbolSuggestion.bind(this)); 132 | }); 133 | } 134 | moduleSuggestions() { 135 | return __awaiter(this, void 0, void 0, function* () { 136 | return this.processSuggestions(this.backend.getCompletionsForModule.bind(this.backend), undefined, (s, prefix) => this.buildSimpleSuggestion('import', s, prefix)); 137 | }); 138 | } 139 | preprocessorSuggestions(pragmaList) { 140 | let f; 141 | const kwrx = new RegExp(`\\b(${pragmaList.join('|')})\\b`); 142 | const kw = this.lineSearch(kwrx)[0]; 143 | let label = ''; 144 | let rx; 145 | switch (false) { 146 | case kw !== 'OPTIONS_GHC': 147 | rx = /[\w-]+$/; 148 | label = 'GHC Flag'; 149 | f = this.backend.getCompletionsForCompilerOptions; 150 | break; 151 | case kw !== 'LANGUAGE': 152 | label = 'Language'; 153 | f = this.backend.getCompletionsForLanguagePragmas; 154 | break; 155 | case !!kw: 156 | label = 'Pragma'; 157 | f = (b, p) => __awaiter(this, void 0, void 0, function* () { return fuzzaldrin_1.filter(pragmaList, p); }); 158 | break; 159 | default: 160 | return []; 161 | } 162 | return this.processSuggestions(f, rx, (s, prefix) => this.buildSimpleSuggestion('keyword', s, prefix, label)); 163 | } 164 | operatorSuggestions() { 165 | return __awaiter(this, void 0, void 0, function* () { 166 | const prefixMatch = this.lineSearch(opertator_regex_1.operatorRx); 167 | if (!prefixMatch) { 168 | return []; 169 | } 170 | const [mod, op] = prefixMatch.slice(1); 171 | if (prefixMatch[0].length < this.mwl) { 172 | return []; 173 | } 174 | const symbols = yield this.backend.getCompletionsForSymbol(this.buffer, `${mod || ''}${op}`, this.options.bufferPosition); 175 | const newSyms = symbols 176 | .filter(({ symbolType }) => symbolType === 'operator'); 177 | const allSyms = fuzzaldrin_1.filter(newSyms, prefixMatch[0], { key: 'qname' }); 178 | return allSyms.map((s) => this.buildSymbolSuggestion(s, prefixMatch[0])); 179 | }); 180 | } 181 | } 182 | exports.SuggestionBuilder = SuggestionBuilder; 183 | //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"suggestion-builder.js","sourceRoot":"","sources":["../src/suggestion-builder.ts"],"names":[],"mappings":"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","sourcesContent":["import { Range } from 'atom'\nimport { filter } from 'fuzzaldrin'\nimport CB = UPI.CompletionBackend\n\nconst typeScope = ['meta.type-signature.haskell']\nconst sourceScope = ['source.haskell']\nconst moduleScope = ['meta.import.haskell', 'support.other.module.haskell']\nconst preprocessorScope = ['meta.preprocessor.haskell']\nconst instancePreprocessorScope = ['meta.declaration.instance.haskell', 'meta.preprocessor.haskell']\nconst exportsScope = ['meta.import.haskell', 'meta.declaration.exports.haskell']\n\nconst pragmaWords = [\n  'LANGUAGE', 'OPTIONS_GHC', 'INCLUDE', 'WARNING', 'DEPRECATED', 'INLINE',\n  'NOINLINE', 'ANN', 'LINE', 'RULES', 'SPECIALIZE', 'UNPACK', 'SOURCE',\n]\n\nconst instancePragmaWords = [\n  'INCOHERENT',\n  'OVERLAPPABLE',\n  'OVERLAPPING',\n  'OVERLAPS',\n]\n\nimport { operatorRx, identRx } from './opertator-regex'\n\nexport interface IOptions {\n  editor: AtomTypes.TextEditor\n  bufferPosition: AtomTypes.Point\n  activatedManually: boolean\n  scopeDescriptor: AtomTypes.ScopeDescriptor\n}\n\nexport interface ISuggestion {\n  text: string\n  rightLabel?: string\n  type: CB.SymbolType | 'import' | 'keyword'\n  replacementPrefix: string\n  description?: string\n}\n\ntype GetSymbolsCallback<T> = (buffer: AtomTypes.TextBuffer, prefix: string, position: AtomTypes.Point) => Promise<T[]>\n\nexport class SuggestionBuilder {\n  private buffer: AtomTypes.TextBuffer\n  private lineRange: AtomTypes.Range\n  private line: string\n  private mwl: number\n  constructor(private options: IOptions, private backend: CB.ICompletionBackend) {\n    this.buffer = this.options.editor.getBuffer()\n    this.lineRange = new Range(\n      [this.options.bufferPosition.row, 0],\n      this.options.bufferPosition,\n    )\n    this.line = this.buffer.getTextInRange(this.lineRange)\n    this.mwl =\n      this.options.activatedManually ?\n        0\n        :\n        atom.config.get('autocomplete-plus.minimumWordLength')\n  }\n\n  public async getSuggestions(): Promise<ISuggestion[]> {\n    if (this.isIn(instancePreprocessorScope)) {\n      return this.preprocessorSuggestions(instancePragmaWords)\n    } else if (this.isIn(typeScope)) {\n      return this.symbolSuggestions(this.backend.getCompletionsForType.bind(this.backend))\n    } else if (this.isIn(moduleScope)) {\n      return this.moduleSuggestions()\n    } else if (this.isIn(exportsScope)) {\n      return this.symbolSuggestions(this.backend.getCompletionsForSymbolInModule.bind(this.backend))\n    } else if (this.isIn(preprocessorScope)) {\n      return this.preprocessorSuggestions(pragmaWords)\n      // should be last as least sepcialized\n    } else if (this.isIn(sourceScope)) {\n      if (this.getPrefix().startsWith('_')) {\n        return this.symbolSuggestions(this.backend.getCompletionsForHole.bind(this.backend))\n      } else if (this.getPrefix() === '' && this.getPrefix(operatorRx) !== '') {\n        return this.operatorSuggestions()\n      } else {\n        return this.symbolSuggestions(this.backend.getCompletionsForSymbol.bind(this.backend))\n      }\n    } else {\n      return []\n    }\n  }\n\n  private lineSearch(rx: RegExp, idx: number = 0) {\n    const match = this.line.match(rx)\n    if (match) {\n      return match\n    } else {\n      return ['']\n    }\n  }\n\n  private isIn(scope: string[]) {\n    return scope.every((s1) => this.options.scopeDescriptor.getScopesArray().includes(s1))\n  }\n\n  private getPrefix(rx?: RegExp) {\n    if (!rx) { rx = identRx }\n    return this.lineSearch(rx)[0]\n  }\n\n  private buildSymbolSuggestion(s: CB.ISymbol, prefix: string): ISuggestion {\n    return {\n      text: s.qname ? s.qname : s.name,\n      rightLabel: (s.module ? s.module.name : undefined),\n      type: s.symbolType,\n      replacementPrefix: prefix,\n      description: this.nameFix(s) + ' :: ' + s.typeSignature,\n    }\n  }\n\n  private nameFix(s: CB.ISymbol) {\n    if (s.symbolType === 'operator') {\n      return `(${s.name})`\n    } else {\n      return s.name\n    }\n  }\n\n  private buildSimpleSuggestion(\n    type: 'import' | 'keyword', text: string, prefix: string, label?: string,\n  ): ISuggestion {\n    return {\n      text,\n      type,\n      replacementPrefix: prefix,\n      rightLabel: label,\n    }\n  }\n\n  private async processSuggestions<T>(\n    f: GetSymbolsCallback<T>, rx: RegExp | undefined, p: (s: T, p: string) => ISuggestion,\n  ) {\n    const prefix = this.getPrefix(rx)\n    if (prefix.length < this.mwl) {\n      return []\n    }\n    const symbols = await f(this.buffer, prefix, this.options.bufferPosition)\n    return symbols.map((s) => p(s, prefix))\n  }\n\n  private async symbolSuggestions(f: GetSymbolsCallback<CB.ISymbol>, rx?: RegExp) {\n    return this.processSuggestions(f, rx, this.buildSymbolSuggestion.bind(this))\n  }\n\n  private async moduleSuggestions() {\n    return this.processSuggestions(this.backend.getCompletionsForModule.bind(this.backend), undefined, (s, prefix) =>\n      this.buildSimpleSuggestion('import', s, prefix))\n  }\n\n  private preprocessorSuggestions(pragmaList: string[]) {\n    let f: GetSymbolsCallback<string>\n    const kwrx = new RegExp(`\\\\b(${pragmaList.join('|')})\\\\b`)\n    const kw = this.lineSearch(kwrx)[0]\n    let label = ''\n    let rx\n    switch (false) {\n      case kw !== 'OPTIONS_GHC':\n        rx = /[\\w-]+$/\n        label = 'GHC Flag'\n        f = this.backend.getCompletionsForCompilerOptions\n        break\n      case kw !== 'LANGUAGE':\n        label = 'Language'\n        f = this.backend.getCompletionsForLanguagePragmas\n        break\n      case !!kw:\n        label = 'Pragma'\n        f = async (b, p) => filter(pragmaList, p)\n        break\n      default:\n        return []\n    }\n\n    return this.processSuggestions(f, rx, (s, prefix) =>\n      this.buildSimpleSuggestion('keyword', s, prefix, label))\n  }\n\n  private async operatorSuggestions() {\n    const prefixMatch = this.lineSearch(operatorRx)\n    if (!prefixMatch) { return [] }\n    const [mod, op] = prefixMatch.slice(1)\n    if (prefixMatch[0].length < this.mwl) {\n      return []\n    }\n    const symbols =\n      await this.backend.getCompletionsForSymbol(this.buffer, `${mod || ''}${op}`, this.options.bufferPosition)\n    const newSyms =\n      symbols\n        .filter(({ symbolType }) => symbolType === 'operator')\n    const allSyms = filter(newSyms, prefixMatch[0], { key: 'qname' })\n    return allSyms.map((s) => this.buildSymbolSuggestion(s, prefixMatch[0]))\n  }\n}\n"]} --------------------------------------------------------------------------------