├── tslint.json
├── .prettierrc
├── .gitignore
├── .gitmodules
├── src
    ├── node.d.ts
    ├── atom.d.ts
    ├── util.ts
    ├── views
    │   ├── editor.tsx
    │   ├── button.tsx
    │   └── ide-haskell-repl-view.tsx
    ├── command-history.ts
    ├── ide-haskell-repl-bg.ts
    ├── setup-ghci-wrapper.ts
    ├── config.ts
    ├── ghci.ts
    ├── ide-haskell-repl.ts
    ├── upiConsumer.ts
    ├── interactive-process.ts
    └── ide-haskell-repl-base.ts
├── spec
    ├── tsconfig.json
    ├── tslint.json
    ├── package.spec.ts
    └── interactive-process.spec.ts
├── keymaps
    └── ide-haskell-repl.cson
├── README.md
├── coffeelint.json
├── LICENSE.md
├── .travis.yml
├── tsconfig.json
├── lib
    ├── views
    │   ├── editor.js
    │   └── button.js
    ├── util.js
    ├── command-history.js
    ├── config.js
    ├── ide-haskell-repl-bg.js
    ├── setup-ghci-wrapper.js
    ├── ghci.js
    ├── ide-haskell-repl.js
    ├── upiConsumer.js
    └── interactive-process.js
├── package.json
├── styles
    └── ide-haskell-repl.less
└── CHANGELOG.md


/tslint.json:
--------------------------------------------------------------------------------
1 | { "extends": "atom-haskell-tslint-rules" }
2 | 


--------------------------------------------------------------------------------
/.prettierrc:
--------------------------------------------------------------------------------
1 | semi: false
2 | singleQuote: true
3 | trailingComma: all
4 | arrowParens: always
5 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | .DS_Store
2 | npm-debug.log
3 | node_modules
4 | lib/**/*.d.ts
5 | package-lock.json
6 | 


--------------------------------------------------------------------------------
/.gitmodules:
--------------------------------------------------------------------------------
1 | [submodule "typings"]
2 | 	path = typings
3 | 	url = git@github.com:atom-haskell/typings.git
4 | 


--------------------------------------------------------------------------------
/src/node.d.ts:
--------------------------------------------------------------------------------
1 | namespace NodeJS {
2 |   interface Process {
3 |     activateUvLoop(): void
4 |   }
5 | }
6 | 


--------------------------------------------------------------------------------
/spec/tsconfig.json:
--------------------------------------------------------------------------------
1 | {
2 |   "compileOnSave": false,
3 |   "extends": "../tsconfig.json",
4 |   "include": ["./**.ts"],
5 |   "exclude": []
6 | }
7 | 


--------------------------------------------------------------------------------
/spec/tslint.json:
--------------------------------------------------------------------------------
1 | {
2 |   "extends": "../tslint.json",
3 |   "rules": {
4 |     "no-unused-expression": false,
5 |     "no-non-null-assertion": false,
6 |     "totality-check": false
7 |   }
8 | }
9 | 


--------------------------------------------------------------------------------
/src/atom.d.ts:
--------------------------------------------------------------------------------
1 | export {}
2 | declare module 'atom' {
3 |   type TWatchEditor = (editor: TextEditor, labels: string[]) => Disposable
4 |   interface CommandRegistryTargetMap {
5 |     'atom-text-editor:not(.ide-haskell-repl)': TextEditorElement
6 |     'atom-text-editor.ide-haskell-repl': TextEditorElement
7 |   }
8 | }
9 | 


--------------------------------------------------------------------------------
/src/util.ts:
--------------------------------------------------------------------------------
 1 | import * as UPI from 'atom-haskell-upi'
 2 | 
 3 | export function handlePromise(somePromise: Promise<any>): void {
 4 |   somePromise.catch((e: Error) => {
 5 |     atom.notifications.addFatalError(e.name, {
 6 |       detail: e.message,
 7 |       stack: e.stack,
 8 |     })
 9 |   })
10 | }
11 | 
12 | export function getText(m: UPI.TMessage): string {
13 |   if (typeof m === 'string') {
14 |     return m
15 |   } else {
16 |     if ('text' in m) return m.text
17 |     else return m.html
18 |   }
19 | }
20 | 


--------------------------------------------------------------------------------
/src/views/editor.tsx:
--------------------------------------------------------------------------------
 1 | export interface IProps extends JSX.Props {
 2 |   element: HTMLElement
 3 | }
 4 | 
 5 | // tslint:disable-next-line:no-unsafe-any
 6 | export class Editor implements JSX.ElementClass {
 7 |   public element: HTMLElement
 8 |   constructor(public props: IProps) {
 9 |     this.element = props.element
10 |     this.element.classList.add('ide-haskell-repl')
11 |   }
12 | 
13 |   public async update(props: IProps) {
14 |     this.element = props.element
15 |     this.element.classList.add('ide-haskell-repl')
16 |     return Promise.resolve()
17 |   }
18 | }
19 | 


--------------------------------------------------------------------------------
/spec/package.spec.ts:
--------------------------------------------------------------------------------
 1 | import { expect } from 'chai'
 2 | import { join } from 'path'
 3 | 
 4 | const pkg = join(__dirname, '..')
 5 | 
 6 | describe('package', function() {
 7 |   this.timeout(60000)
 8 |   it('should activate', async () => {
 9 |     const packages: any = atom.packages
10 | 
11 |     // Load package, but it won't activate until the grammar is used
12 |     const promise = atom.packages.activatePackage(pkg)
13 | 
14 |     packages.triggerActivationHook('language-haskell:grammar-used')
15 |     packages.triggerDeferredActivationHooks()
16 | 
17 |     await promise
18 | 
19 |     expect(atom.packages.isPackageActive('ide-haskell-repl')).to.be.true
20 |   })
21 | })
22 | 


--------------------------------------------------------------------------------
/keymaps/ide-haskell-repl.cson:
--------------------------------------------------------------------------------
 1 | '.platform-linux atom-text-editor.ide-haskell-repl':
 2 |   'shift-enter': 'ide-haskell-repl:exec-command'
 3 |   'shift-up': 'ide-haskell-repl:history-back'
 4 |   'shift-down': 'ide-haskell-repl:history-forward'
 5 |   'ctrl-shift-r': 'ide-haskell-repl:ghci-reload'
 6 |   'ctrl-shift-c': 'ide-haskell-repl:ghci-interrupt'
 7 | 
 8 | '.platform-win32 atom-text-editor.ide-haskell-repl':
 9 |   'shift-enter': 'ide-haskell-repl:exec-command'
10 |   'shift-up': 'ide-haskell-repl:history-back'
11 |   'shift-down': 'ide-haskell-repl:history-forward'
12 |   'ctrl-shift-r': 'ide-haskell-repl:ghci-reload'
13 |   'ctrl-shift-c': 'ide-haskell-repl:ghci-interrupt'
14 | 
15 | '.platform-darwin atom-text-editor.ide-haskell-repl':
16 |   'cmd-enter': 'ide-haskell-repl:exec-command'
17 |   'shift-up': 'ide-haskell-repl:history-back'
18 |   'shift-down': 'ide-haskell-repl:history-forward'
19 |   'ctrl-shift-r': 'ide-haskell-repl:ghci-reload'
20 |   'ctrl-shift-c': 'ide-haskell-repl:ghci-interrupt'
21 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # IDE-Haskell REPL ![](https://david-dm.org/atom-haskell/ide-haskell-repl.svg)
 2 | 
 3 | ***This package is in beta.***
 4 | 
 5 | This package provides a way to interact with ghci (or, more precisely, `cabal repl` or `stack ghci`) from Atom.
 6 | 
 7 | ![image](https://cloud.githubusercontent.com/assets/7275622/24383478/c3ae1ae4-1365-11e7-88a6-0c4877b23fc1.png)
 8 | 
 9 | ## Documentation
10 | 
11 | Please refer to documentation site https://atom-haskell.github.io. In particular, see [here](https://atom-haskell.github.io/extra-packages/ide-haskell-repl/#using-on-windows) when running `ide-haskell-repl` on Windows.
12 | 
13 | ## License
14 | 
15 | Copyright © 2015 Atom-Haskell.
16 | 
17 | Contributors (by number of commits):
18 | 
19 | <!-- BEGIN CONTRIBUTORS LIST -->
20 | * Nikolay Yakimov
21 | * yaeti
22 | * Yakov Borevich
23 | * soiamsoNG
24 | 
25 | <!-- END CONTRIBUTORS LIST -->
26 | 
27 | See [LICENSE.md][LICENSE] for details.
28 | 
29 | [LICENSE]: https://github.com/atom-haskell/ide-haskell-repl/blob/master/LICENSE.md
30 | 


--------------------------------------------------------------------------------
/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 | 


--------------------------------------------------------------------------------
/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 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
 1 | ### Project specific config ###
 2 | language: generic
 3 | 
 4 | env:
 5 |   global:
 6 |     - APM_TEST_PACKAGES=""
 7 |     - ATOM_LINT_WITH_BUNDLED_NODE="true"
 8 | 
 9 |   matrix:
10 |     - ATOM_CHANNEL=stable
11 |     - ATOM_CHANNEL=beta
12 | 
13 | os:
14 |   - linux
15 | 
16 | # Use sed to replace the SSH URL with the public URL, then initialize submodules
17 | before_install:
18 |     - sed -i 's/git@github.com:/https:\/\/github.com\//' .gitmodules
19 |     - git submodule update --init --recursive
20 | 
21 | ### Generic setup follows ###
22 | script:
23 |   - curl -s -O https://raw.githubusercontent.com/atom/ci/master/build-package.sh
24 |   - chmod u+x build-package.sh
25 |   - ./build-package.sh
26 |   - npm run build
27 |   - npm run test
28 | 
29 | notifications:
30 |   email:
31 |     on_success: never
32 |     on_failure: change
33 | 
34 | branches:
35 |   only:
36 |     - master
37 | 
38 | git:
39 |   depth: 10
40 |   submodules: false
41 | 
42 | sudo: false
43 | 
44 | dist: trusty
45 | 
46 | addons:
47 |   apt:
48 |     packages:
49 |     - build-essential
50 |     - fakeroot
51 |     - git
52 |     - libsecret-1-dev
53 | 


--------------------------------------------------------------------------------
/src/command-history.ts:
--------------------------------------------------------------------------------
 1 | export class CommandHistory {
 2 |   private back: string[]
 3 |   private current: number
 4 |   private temp: string
 5 |   constructor(history: string[] = []) {
 6 |     this.back = history
 7 |     this.current = -1
 8 |     this.temp = ''
 9 |   }
10 | 
11 |   public goBack(current: string): string {
12 |     if (this.current === -1) {
13 |       this.temp = current
14 |     }
15 |     this.current += 1
16 |     if (this.current >= this.back.length) {
17 |       this.current = this.back.length - 1
18 |     }
19 |     if (this.current < 0) {
20 |       this.current = -1
21 |       return this.temp
22 |     }
23 |     return this.back[this.current]
24 |   }
25 | 
26 |   public peek(shift: number): string | undefined {
27 |     return this.back[this.current - shift]
28 |   }
29 | 
30 |   public goForward(): string {
31 |     if (this.current <= 0) {
32 |       this.current = -1
33 |       return this.temp
34 |     }
35 |     this.current -= 1
36 |     return this.back[this.current]
37 |   }
38 | 
39 |   public save(current: string): void {
40 |     this.current = -1
41 |     this.back.unshift(current)
42 |   }
43 | 
44 |   public serialize(): string[] {
45 |     return this.back
46 |   }
47 | }
48 | 


--------------------------------------------------------------------------------
/spec/interactive-process.spec.ts:
--------------------------------------------------------------------------------
 1 | import { InteractiveProcess } from '../lib/interactive-process'
 2 | 
 3 | import { expect } from 'chai'
 4 | 
 5 | describe('InteractiveProcess', () => {
 6 |   it('works', async () => {
 7 |     const noop = () => undefined
 8 |     const ip = new InteractiveProcess('cat', [], noop, {}, /.*$/)
 9 |     let i = 1
10 |     await ip.request('Hello\nworld\n', (line) => {
11 |       switch (i) {
12 |         case 1:
13 |           expect(line.type).to.equal('stdin')
14 |           if (line.type === 'stdin') {
15 |             expect(line.line).to.equal('Hello\nworld\n')
16 |           }
17 |           break
18 |         case 2:
19 |           expect(line.type).to.equal('prompt')
20 |           if (line.type === 'prompt') {
21 |             expect(line.prompt[0]).to.equal('Hello')
22 |           }
23 |           break
24 |         case 3:
25 |           expect(line.type).to.equal('prompt')
26 |           if (line.type === 'prompt') {
27 |             expect(line.prompt[0]).to.equal('world')
28 |           }
29 |           break
30 |         default:
31 |           throw new Error(`Unexpected ${i}: ${JSON.stringify(line)}`)
32 |       }
33 |       i++
34 |     })
35 |     ip.destroy()
36 |   })
37 | })
38 | 


--------------------------------------------------------------------------------
/tsconfig.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "compilerOptions": {
 3 |     "target": "es2017",
 4 |     "module": "commonjs",
 5 |     "moduleResolution": "node",
 6 |     "isolatedModules": false,
 7 |     "jsx": "react",
 8 |     "experimentalDecorators": true,
 9 |     "emitDecoratorMetadata": true,
10 |     "declaration": true,
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": false,
23 |     "lib": ["dom", "es2017", "esnext.asynciterable"],
24 |     "strict": true,
25 |     "importHelpers": true,
26 |     "noFallthroughCasesInSwitch": true,
27 |     "noImplicitReturns": true,
28 |     "noUnusedLocals": true,
29 |     "noUnusedParameters": true,
30 |     "typeRoots": ["./typings", "./node_modules/@types"],
31 |     "plugins": [{ "name": "typescript-tslint-plugin" }],
32 |     "newLine": "LF",
33 |     "skipLibCheck": true
34 |   },
35 |   "exclude": ["node_modules", "spec"],
36 |   "include": ["src/**/*.ts", "src/**/*.tsx", "src/**/*.js"],
37 |   "compileOnSave": true,
38 |   "experimentalDecorators": true
39 | }
40 | 


--------------------------------------------------------------------------------
/lib/views/editor.js:
--------------------------------------------------------------------------------
 1 | "use strict";
 2 | Object.defineProperty(exports, "__esModule", { value: true });
 3 | class Editor {
 4 |     constructor(props) {
 5 |         this.props = props;
 6 |         this.element = props.element;
 7 |         this.element.classList.add('ide-haskell-repl');
 8 |     }
 9 |     async update(props) {
10 |         this.element = props.element;
11 |         this.element.classList.add('ide-haskell-repl');
12 |         return Promise.resolve();
13 |     }
14 | }
15 | exports.Editor = Editor;
16 | //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZWRpdG9yLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3ZpZXdzL2VkaXRvci50c3giXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFLQSxNQUFhLE1BQU07SUFFakIsWUFBbUIsS0FBYTtRQUFiLFVBQUssR0FBTCxLQUFLLENBQVE7UUFDOUIsSUFBSSxDQUFDLE9BQU8sR0FBRyxLQUFLLENBQUMsT0FBTyxDQUFBO1FBQzVCLElBQUksQ0FBQyxPQUFPLENBQUMsU0FBUyxDQUFDLEdBQUcsQ0FBQyxrQkFBa0IsQ0FBQyxDQUFBO0lBQ2hELENBQUM7SUFFTSxLQUFLLENBQUMsTUFBTSxDQUFDLEtBQWE7UUFDL0IsSUFBSSxDQUFDLE9BQU8sR0FBRyxLQUFLLENBQUMsT0FBTyxDQUFBO1FBQzVCLElBQUksQ0FBQyxPQUFPLENBQUMsU0FBUyxDQUFDLEdBQUcsQ0FBQyxrQkFBa0IsQ0FBQyxDQUFBO1FBQzlDLE9BQU8sT0FBTyxDQUFDLE9BQU8sRUFBRSxDQUFBO0lBQzFCLENBQUM7Q0FDRjtBQVpELHdCQVlDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGludGVyZmFjZSBJUHJvcHMgZXh0ZW5kcyBKU1guUHJvcHMge1xuICBlbGVtZW50OiBIVE1MRWxlbWVudFxufVxuXG4vLyB0c2xpbnQ6ZGlzYWJsZS1uZXh0LWxpbmU6bm8tdW5zYWZlLWFueVxuZXhwb3J0IGNsYXNzIEVkaXRvciBpbXBsZW1lbnRzIEpTWC5FbGVtZW50Q2xhc3Mge1xuICBwdWJsaWMgZWxlbWVudDogSFRNTEVsZW1lbnRcbiAgY29uc3RydWN0b3IocHVibGljIHByb3BzOiBJUHJvcHMpIHtcbiAgICB0aGlzLmVsZW1lbnQgPSBwcm9wcy5lbGVtZW50XG4gICAgdGhpcy5lbGVtZW50LmNsYXNzTGlzdC5hZGQoJ2lkZS1oYXNrZWxsLXJlcGwnKVxuICB9XG5cbiAgcHVibGljIGFzeW5jIHVwZGF0ZShwcm9wczogSVByb3BzKSB7XG4gICAgdGhpcy5lbGVtZW50ID0gcHJvcHMuZWxlbWVudFxuICAgIHRoaXMuZWxlbWVudC5jbGFzc0xpc3QuYWRkKCdpZGUtaGFza2VsbC1yZXBsJylcbiAgICByZXR1cm4gUHJvbWlzZS5yZXNvbHZlKClcbiAgfVxufVxuIl19


--------------------------------------------------------------------------------
/lib/util.js:
--------------------------------------------------------------------------------
 1 | "use strict";
 2 | Object.defineProperty(exports, "__esModule", { value: true });
 3 | function handlePromise(somePromise) {
 4 |     somePromise.catch((e) => {
 5 |         atom.notifications.addFatalError(e.name, {
 6 |             detail: e.message,
 7 |             stack: e.stack,
 8 |         });
 9 |     });
10 | }
11 | exports.handlePromise = handlePromise;
12 | function getText(m) {
13 |     if (typeof m === 'string') {
14 |         return m;
15 |     }
16 |     else {
17 |         if ('text' in m)
18 |             return m.text;
19 |         else
20 |             return m.html;
21 |     }
22 | }
23 | exports.getText = getText;
24 | //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy91dGlsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBRUEsU0FBZ0IsYUFBYSxDQUFDLFdBQXlCO0lBQ3JELFdBQVcsQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFRLEVBQUUsRUFBRTtRQUM3QixJQUFJLENBQUMsYUFBYSxDQUFDLGFBQWEsQ0FBQyxDQUFDLENBQUMsSUFBSSxFQUFFO1lBQ3ZDLE1BQU0sRUFBRSxDQUFDLENBQUMsT0FBTztZQUNqQixLQUFLLEVBQUUsQ0FBQyxDQUFDLEtBQUs7U0FDZixDQUFDLENBQUE7SUFDSixDQUFDLENBQUMsQ0FBQTtBQUNKLENBQUM7QUFQRCxzQ0FPQztBQUVELFNBQWdCLE9BQU8sQ0FBQyxDQUFlO0lBQ3JDLElBQUksT0FBTyxDQUFDLEtBQUssUUFBUSxFQUFFO1FBQ3pCLE9BQU8sQ0FBQyxDQUFBO0tBQ1Q7U0FBTTtRQUNMLElBQUksTUFBTSxJQUFJLENBQUM7WUFBRSxPQUFPLENBQUMsQ0FBQyxJQUFJLENBQUE7O1lBQ3pCLE9BQU8sQ0FBQyxDQUFDLElBQUksQ0FBQTtLQUNuQjtBQUNILENBQUM7QUFQRCwwQkFPQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCAqIGFzIFVQSSBmcm9tICdhdG9tLWhhc2tlbGwtdXBpJ1xuXG5leHBvcnQgZnVuY3Rpb24gaGFuZGxlUHJvbWlzZShzb21lUHJvbWlzZTogUHJvbWlzZTxhbnk+KTogdm9pZCB7XG4gIHNvbWVQcm9taXNlLmNhdGNoKChlOiBFcnJvcikgPT4ge1xuICAgIGF0b20ubm90aWZpY2F0aW9ucy5hZGRGYXRhbEVycm9yKGUubmFtZSwge1xuICAgICAgZGV0YWlsOiBlLm1lc3NhZ2UsXG4gICAgICBzdGFjazogZS5zdGFjayxcbiAgICB9KVxuICB9KVxufVxuXG5leHBvcnQgZnVuY3Rpb24gZ2V0VGV4dChtOiBVUEkuVE1lc3NhZ2UpOiBzdHJpbmcge1xuICBpZiAodHlwZW9mIG0gPT09ICdzdHJpbmcnKSB7XG4gICAgcmV0dXJuIG1cbiAgfSBlbHNlIHtcbiAgICBpZiAoJ3RleHQnIGluIG0pIHJldHVybiBtLnRleHRcbiAgICBlbHNlIHJldHVybiBtLmh0bWxcbiAgfVxufVxuIl19


--------------------------------------------------------------------------------
/src/views/button.tsx:
--------------------------------------------------------------------------------
 1 | import { CompositeDisposable } from 'atom'
 2 | import etch = require('etch')
 3 | import { IdeHaskellReplView } from './ide-haskell-repl-view'
 4 | 
 5 | export interface IProps extends JSX.Props {
 6 |   cls: string
 7 |   parent: IdeHaskellReplView
 8 |   tooltip: string | (() => string)
 9 |   command: string
10 |   state?: boolean
11 | }
12 | 
13 | // tslint:disable-next-line:no-unsafe-any
14 | export class Button implements JSX.ElementClass {
15 |   private element!: HTMLElement
16 |   private target: HTMLElement
17 |   private disposables: CompositeDisposable
18 |   private clslst: Set<string>
19 |   constructor(public props: IProps) {
20 |     this.disposables = new CompositeDisposable()
21 |     this.clslst = new Set()
22 |     this.clslst.add(this.props.cls)
23 |     this.updateState(this.props.state)
24 |     etch.initialize(this)
25 |     this.target = atom.views.getView(this.props.parent.editor)
26 |     this.disposables.add(
27 |       atom.tooltips.add(this.element, {
28 |         title: this.props.tooltip,
29 |         keyBindingCommand: this.props.command,
30 |         keyBindingTarget: this.target,
31 |       }),
32 |     )
33 |   }
34 | 
35 |   public render() {
36 |     return (
37 |       // tslint:disable:no-unsafe-any
38 |       <button
39 |         className={Array.from(this.clslst.values()).join(' ')}
40 |         on={{ click: this.click.bind(this) }}
41 |       />
42 |       // tslint:enable:no-unsafe-any
43 |     )
44 |   }
45 | 
46 |   public async destroy() {
47 |     await etch.destroy(this)
48 |     this.disposables.dispose()
49 |   }
50 | 
51 |   public async update(props: IProps) {
52 |     if (this.props.state === props.state) {
53 |       return Promise.resolve()
54 |     }
55 |     this.props.state = props.state
56 |     this.updateState(this.props.state)
57 |     return etch.update(this)
58 |   }
59 | 
60 |   public click() {
61 |     if (this.target) {
62 |       atom.commands.dispatch(this.target, this.props.command)
63 |     }
64 |   }
65 | 
66 |   private updateState(state?: boolean) {
67 |     if (state) {
68 |       this.clslst.add('enabled')
69 |     } else {
70 |       this.clslst.delete('enabled')
71 |     }
72 |   }
73 | }
74 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "ide-haskell-repl",
 3 |   "main": "./lib/ide-haskell-repl",
 4 |   "version": "0.11.1",
 5 |   "description": "Haskell REPL support for ide-haskell",
 6 |   "keywords": [
 7 |     "ide-haskell",
 8 |     "ide",
 9 |     "haskell",
10 |     "repl"
11 |   ],
12 |   "activationHooks": [
13 |     "language-haskell:grammar-used"
14 |   ],
15 |   "repository": "https://github.com/atom-haskell/ide-haskell-repl",
16 |   "license": "MIT",
17 |   "engines": {
18 |     "atom": ">=1.24.0 <2.0.0"
19 |   },
20 |   "scripts": {
21 |     "build": "tsc -p .",
22 |     "prettier": "prettier --write 'src/**/*.ts?(x)' 'spec/**/*.ts?(x)'",
23 |     "prettier-check": "prettier -l 'src/**/*.ts?(x)' 'spec/**/*.ts?(x)'",
24 |     "typecheck": "tsc --noEmit -p . && tsc --noEmit -p spec",
25 |     "lint": "tslint --project . && tslint --project spec",
26 |     "test": "npm run typecheck && npm run lint && npm run prettier-check"
27 |   },
28 |   "atomTestRunner": "./node_modules/atom-ts-spec-runner/runner.js",
29 |   "dependencies": {
30 |     "atom-haskell-utils": "^2.1.0",
31 |     "atom-highlight": "^0.4.2",
32 |     "etch": "^0.14.0",
33 |     "fuzzaldrin": "^2.1.0",
34 |     "promise-queue": "^2.2.5",
35 |     "tree-kill": "^1.2.2",
36 |     "tslib": "^1.11.1"
37 |   },
38 |   "consumedServices": {
39 |     "ide-haskell-upi": {
40 |       "description": "Uses ide-haskell's unified pluggable interface",
41 |       "versions": {
42 |         "^0.3.0": "consumeUPI"
43 |       }
44 |     },
45 |     "autocomplete.watchEditor": {
46 |       "versions": {
47 |         "^1.0.0": "consumeWatchEditor"
48 |       }
49 |     }
50 |   },
51 |   "providedServices": {
52 |     "autocomplete.provider": {
53 |       "versions": {
54 |         "3.0.0": "autocompleteProvider_3_0_0"
55 |       }
56 |     }
57 |   },
58 |   "deserializers": {
59 |     "IdeHaskellReplView": "createReplView"
60 |   },
61 |   "devDependencies": {
62 |     "@types/atom": "^1.40.2",
63 |     "@types/chai": "^4.2.11",
64 |     "@types/fuzzaldrin": "^2.1.2",
65 |     "@types/mocha": "^7.0.2",
66 |     "@types/node": "^10",
67 |     "atom-haskell-tslint-rules": "^0.2.2",
68 |     "atom-ts-spec-runner": "^1.1.1",
69 |     "chai": "^4.2.0",
70 |     "mocha": "^7.1.1",
71 |     "prettier": "^1",
72 |     "ts-node": "^8.8.2",
73 |     "tslint": "^6.1.1",
74 |     "typescript": "~3.8.3",
75 |     "typescript-tslint-plugin": "^0.5.5"
76 |   }
77 | }
78 | 


--------------------------------------------------------------------------------
/src/ide-haskell-repl-bg.ts:
--------------------------------------------------------------------------------
 1 | import { Range } from 'atom'
 2 | import {
 3 |   IContentItem,
 4 |   IdeHaskellReplBase,
 5 |   IViewState,
 6 | } from './ide-haskell-repl-base'
 7 | import * as path from 'path'
 8 | import { UPIConsumer } from './upiConsumer'
 9 | 
10 | export { IViewState, IContentItem }
11 | 
12 | export interface ITypeRecord {
13 |   uri: string
14 |   type: string
15 |   span: [[number, number], [number, number]]
16 | }
17 | 
18 | export class IdeHaskellReplBg extends IdeHaskellReplBase {
19 |   private types: Array<ITypeRecord | undefined> = []
20 |   private gotTypes: Promise<void>
21 |   constructor(consumer: UPIConsumer, state: IViewState) {
22 |     super(Promise.resolve(consumer), state, `bg:${state.uri}`)
23 |     this.gotTypes = this.readyPromise
24 |   }
25 | 
26 |   public async showTypeAt(uri: string, inrange: Range) {
27 |     await this.gotTypes
28 |     const typeRec = this.types.find(
29 |       (tr) =>
30 |         tr !== undefined &&
31 |         tr.uri === uri &&
32 |         Range.fromObject(tr.span).containsRange(inrange),
33 |     )
34 |     if (!typeRec) {
35 |       return undefined
36 |     }
37 |     const { span: range, type: text } = typeRec
38 |     const highlighter = 'hint.type.haskell'
39 |     return { range, text: { text, highlighter } }
40 |   }
41 | 
42 |   public async destroy() {
43 |     this.types = []
44 |     return super.destroy()
45 |   }
46 | 
47 |   public async update() {
48 |     // noop
49 |   }
50 | 
51 |   protected async onInitialLoad() {
52 |     await this.ghciReload() // required to collect types
53 |     await super.onInitialLoad()
54 |   }
55 | 
56 |   protected async onReload() {
57 |     await (this.gotTypes = this.getAllTypes())
58 |     await super.onReload()
59 |   }
60 | 
61 |   protected async getAllTypes(): Promise<void> {
62 |     if (!this.ghci) {
63 |       throw new Error('No GHCI instance!')
64 |     }
65 |     // don't waste time if don't need to
66 |     if (!atom.config.get('ide-haskell-repl.showTypes')) return
67 |     const { stdout } = await this.ghci.writeLines([':all-types'])
68 |     const cwd = this.cwd
69 |       ? this.cwd
70 |       : await IdeHaskellReplBase.getRootDir(this.uri)
71 |     const rx = /^(.*):\((\d+),(\d+)\)-\((\d+),(\d+)\):\s*(.*)$/
72 |     this.types = stdout.map((line) => {
73 |       const match = line.match(rx)
74 |       if (!match) return undefined
75 |       return {
76 |         uri: path.isAbsolute(match[1])
77 |           ? match[1]
78 |           : cwd.getFile(match[1]).getPath(),
79 |         type: match[6],
80 |         span: [
81 |           [parseInt(match[2], 10) - 1, parseInt(match[3], 10) - 1],
82 |           [parseInt(match[4], 10) - 1, parseInt(match[5], 10) - 1],
83 |         ],
84 |       } as ITypeRecord
85 |     })
86 |   }
87 | }
88 | 


--------------------------------------------------------------------------------
/src/setup-ghci-wrapper.ts:
--------------------------------------------------------------------------------
 1 | import { createHash } from 'crypto'
 2 | import { Directory } from 'atom'
 3 | 
 4 | export async function setupGhciWrapper() {
 5 |   const downloadUrl =
 6 |     'https://github.com/atom-haskell/win-ghci-wrapper/releases/download/v0.0.2/ghci-wrapper.exe'
 7 |   const expectedDigest = '4663295d71a5057dee41945a52d39ed61fcd8830'
 8 |   try {
 9 |     atom.notifications.addInfo('GHCi Wrapper setup started...')
10 |     const buf = await downloadFile(downloadUrl)
11 |     checkHash(buf, expectedDigest)
12 |     const filePath = await writeFile(buf)
13 |     atom.config.set('ide-haskell-repl.ghciWrapperPath', filePath)
14 |     atom.notifications.addSuccess('GHCi Wrapper setup finished!')
15 |   } catch (e) {
16 |     // tslint:disable-next-line: no-null-keyword
17 |     if (e != null) {
18 |       atom.notifications.addFatalError('GHCi wrapper setup failed', {
19 |         stack: e.stack,
20 |         detail: e.message,
21 |         dismissable: true,
22 |       })
23 |     }
24 |   }
25 | }
26 | 
27 | async function downloadFile(url: string): Promise<Buffer> {
28 |   const result = await window.fetch(url, {
29 |     redirect: 'follow',
30 |   })
31 |   if (!result.ok) {
32 |     atom.notifications.addError('Getting ghci-wrapper.exe failed', {
33 |       detail: result.statusText,
34 |       dismissable: true,
35 |     })
36 |     throw undefined
37 |   }
38 |   return Buffer.from(await result.arrayBuffer())
39 | }
40 | 
41 | function checkHash(buf: Buffer, expected: string): void {
42 |   const hash = createHash('sha1')
43 |   hash.update(buf)
44 |   const digest = hash.digest('hex')
45 |   if (digest !== expected) {
46 |     atom.notifications.addError(
47 |       'Got ghci-wrapper.exe, but hash check failed!',
48 |       {
49 |         detail: `Expected ${expected} but got ${digest}`,
50 |         dismissable: true,
51 |       },
52 |     )
53 |     throw undefined
54 |   }
55 | }
56 | 
57 | async function writeFile(buf: Buffer): Promise<string> {
58 |   const configDir = new Directory(atom.getConfigDirPath())
59 |   const subdir = configDir.getSubdirectory('ide-haskell-repl')
60 |   if (!(await subdir.exists())) {
61 |     if (!(await subdir.create())) {
62 |       atom.notifications.addError(
63 |         'Failed to create directory for ghci-wrapper',
64 |         {
65 |           detail: subdir.getPath(),
66 |           dismissable: true,
67 |         },
68 |       )
69 |       throw undefined
70 |     }
71 |   }
72 |   const file = subdir.getFile('ghci-wrapper.exe')
73 |   const stream = file.createWriteStream()
74 |   try {
75 |     await new Promise<void>((resolve, reject) => {
76 |       stream.on('error', reject)
77 |       stream.write(buf, (error) => {
78 |         stream.off('error', reject)
79 |         // tslint:disable-next-line: no-null-keyword
80 |         if (error != null) reject(error)
81 |         else resolve()
82 |       })
83 |     })
84 |   } finally {
85 |     stream.close()
86 |   }
87 |   return file.getPath()
88 | }
89 | 


--------------------------------------------------------------------------------
/src/config.ts:
--------------------------------------------------------------------------------
  1 | export let config = {
  2 |   defaultRepl: {
  3 |     type: 'string',
  4 |     enum: ['stack', 'cabal-v1', 'ghci', 'cabal-v2'],
  5 |     default: 'ghci',
  6 |     order: 0,
  7 |   },
  8 |   stackPath: {
  9 |     type: 'string',
 10 |     default: 'stack',
 11 |     description: 'Path to stack executable',
 12 |     order: 10,
 13 |   },
 14 |   cabalPath: {
 15 |     type: 'string',
 16 |     default: 'cabal',
 17 |     description: 'Path to cabal executable',
 18 |     order: 20,
 19 |   },
 20 |   legacyCabalV1: {
 21 |     type: 'boolean',
 22 |     default: 'false',
 23 |     description:
 24 |       'Enable if using cabal-install < 2.4.0.0 and wish to use `cabal repl`',
 25 |     order: 21,
 26 |   },
 27 |   ghciPath: {
 28 |     type: 'string',
 29 |     default: 'ghci',
 30 |     description: 'Path to ghci executable',
 31 |     order: 30,
 32 |   },
 33 |   extraArgs: {
 34 |     type: 'array',
 35 |     default: [],
 36 |     description: 'Extra arguments passed to ghci. Comma-separated',
 37 |     items: {
 38 |       type: 'string',
 39 |     },
 40 |     order: 40,
 41 |   },
 42 |   autoReloadRepeat: {
 43 |     type: 'boolean',
 44 |     default: false,
 45 |     description: `Automatically reload and repeat last command on file save.
 46 |     This is only the default. You can toggle this per-editor using
 47 |     ide-haskell-repl:toggle-auto-reload-repeat command`,
 48 |     order: 50,
 49 |   },
 50 |   maxMessages: {
 51 |     type: 'number',
 52 |     default: 100,
 53 |     minimum: 0,
 54 |     description: `Maximum number of ghci messages shown. 0 means unlimited.`,
 55 |     order: 60,
 56 |   },
 57 |   errorsInOutput: {
 58 |     type: 'boolean',
 59 |     default: true,
 60 |     description: `Show interactive errors in output window.`,
 61 |     order: 65,
 62 |   },
 63 |   showTypes: {
 64 |     type: 'boolean',
 65 |     default: false,
 66 |     description: `Show type tooltips in ide-haskell if possible`,
 67 |     order: 70,
 68 |   },
 69 |   checkOnSave: {
 70 |     type: 'boolean',
 71 |     default: false,
 72 |     description: `Reload project in background when file is saved, will effectively
 73 |     check for errors`,
 74 |     order: 80,
 75 |   },
 76 |   ghciWrapperPath: {
 77 |     type: 'string',
 78 |     default: '',
 79 |     description: `This is intended to fix the 'interrupt closes ghci' problem
 80 |     on Windows -- see README for details. This option has no effect on
 81 |     other platforms`,
 82 |     order: 999,
 83 |   },
 84 | }
 85 | 
 86 | // generated by typed-config.js
 87 | declare module 'atom' {
 88 |   interface ConfigValues {
 89 |     'ide-haskell-repl.defaultRepl': 'stack' | 'cabal-v1' | 'ghci' | 'cabal-v2'
 90 |     'ide-haskell-repl.stackPath': string
 91 |     'ide-haskell-repl.cabalPath': string
 92 |     'ide-haskell-repl.legacyCabalV1': boolean
 93 |     'ide-haskell-repl.ghciPath': string
 94 |     'ide-haskell-repl.extraArgs': string[]
 95 |     'ide-haskell-repl.autoReloadRepeat': boolean
 96 |     'ide-haskell-repl.maxMessages': number
 97 |     'ide-haskell-repl.errorsInOutput': boolean
 98 |     'ide-haskell-repl.showTypes': boolean
 99 |     'ide-haskell-repl.checkOnSave': boolean
100 |     'ide-haskell-repl.ghciWrapperPath': string
101 |     'ide-haskell-repl': {
102 |       defaultRepl: 'stack' | 'cabal-v1' | 'ghci' | 'cabal-v2'
103 |       stackPath: string
104 |       cabalPath: string
105 |       legacyCabalV1: boolean
106 |       ghciPath: string
107 |       extraArgs: string[]
108 |       autoReloadRepeat: boolean
109 |       maxMessages: number
110 |       errorsInOutput: boolean
111 |       showTypes: boolean
112 |       checkOnSave: boolean
113 |       ghciWrapperPath: string
114 |     }
115 |   }
116 | }
117 | 


--------------------------------------------------------------------------------
/src/ghci.ts:
--------------------------------------------------------------------------------
  1 | import { hsEscapeString } from 'atom-haskell-utils'
  2 | import { EOL } from 'os'
  3 | import {
  4 |   InteractiveProcess,
  5 |   IRequestResult,
  6 |   TLineCallback,
  7 | } from './interactive-process'
  8 | import Queue = require('promise-queue')
  9 | 
 10 | export { TLineCallback, IRequestResult }
 11 | 
 12 | export interface IOpts {
 13 |   cwd: string
 14 |   atomPath: string
 15 |   command: string
 16 |   args: string[]
 17 |   onExit: (code: number | null) => void
 18 | }
 19 | 
 20 | export class GHCI {
 21 |   private process: InteractiveProcess
 22 |   private readyPromise: Promise<IRequestResult>
 23 |   private onDidExit: (code: number | null) => void
 24 |   private commandQueue: Queue = new Queue(1, 100)
 25 |   constructor(opts: IOpts) {
 26 |     const endPattern = /^#~IDEHASKELLREPL~(.*)~#$/
 27 |     const { cwd, atomPath, command, args, onExit } = opts
 28 |     this.onDidExit = onExit
 29 | 
 30 |     if (process.platform === 'win32') {
 31 |       const spawnArgs = [command, ...args]
 32 |       const cmdexe = atom.config.get('ide-haskell-repl.ghciWrapperPath')
 33 |       if (cmdexe) {
 34 |         spawnArgs.unshift('"' + cmdexe + '"')
 35 |       }
 36 |       this.process = new InteractiveProcess(
 37 |         'chcp 65001 && ',
 38 |         spawnArgs,
 39 |         this.didExit.bind(this),
 40 |         { cwd, shell: true },
 41 |         endPattern,
 42 |       )
 43 |     } else {
 44 |       this.process = new InteractiveProcess(
 45 |         command,
 46 |         args,
 47 |         this.didExit.bind(this),
 48 |         { cwd },
 49 |         endPattern,
 50 |       )
 51 |     }
 52 | 
 53 |     this.readyPromise = this.request(
 54 |       `:set editor \"${atomPath}\" --wait${EOL}` +
 55 |         `:set prompt2 \"\"${EOL}` +
 56 |         `:set prompt-cont \"\"${EOL}` +
 57 |         `:set +c${EOL}` +
 58 |         `:set prompt \"\\n#~IDEHASKELLREPL~%s~#\\n\"${EOL}`,
 59 |     )
 60 |   }
 61 | 
 62 |   public async waitReady() {
 63 |     return this.readyPromise
 64 |   }
 65 | 
 66 |   public isBusy() {
 67 |     return this.commandQueue.getPendingLength() > 0
 68 |   }
 69 | 
 70 |   public async load(uri: string, callback?: TLineCallback) {
 71 |     return this.request(`:load ${hsEscapeString(uri)}${EOL}`, callback)
 72 |   }
 73 | 
 74 |   public async reload(callback?: TLineCallback) {
 75 |     return this.request(`:reload${EOL}`, callback)
 76 |   }
 77 | 
 78 |   public async interrupt() {
 79 |     if (this.process) {
 80 |       if (
 81 |         atom.config.get('ide-haskell-repl.ghciWrapperPath') &&
 82 |         process.platform === 'win32'
 83 |       ) {
 84 |         this.process.writeStdin('\x03')
 85 |       } else {
 86 |         this.process.interrupt()
 87 |       }
 88 |     }
 89 |   }
 90 | 
 91 |   public async writeLines(lines: string[], callback?: TLineCallback) {
 92 |     return this.request(`:{${EOL}${lines.join(EOL)}${EOL}:}${EOL}`, callback)
 93 |   }
 94 | 
 95 |   public writeRaw(raw: string) {
 96 |     this.process.writeStdin(raw)
 97 |   }
 98 | 
 99 |   public async sendCompletionRequest() {
100 |     if (this.isBusy()) return undefined
101 |     // NOTE: this *has* to go around commandQueue, since completion requests
102 |     // shouldn't affect busy status
103 |     return this.process.request(`:complete repl \"\"${EOL}`)
104 |   }
105 | 
106 |   public destroy() {
107 |     this.process.destroy()
108 |   }
109 | 
110 |   private didExit(code: number | null) {
111 |     this.onDidExit(code)
112 |     this.destroy()
113 |   }
114 | 
115 |   private async request(command: string, lineCallback?: TLineCallback) {
116 |     return this.commandQueue.add(async () =>
117 |       this.process.request(command, lineCallback),
118 |     )
119 |   }
120 | }
121 | 


--------------------------------------------------------------------------------
/lib/command-history.js:
--------------------------------------------------------------------------------
 1 | "use strict";
 2 | Object.defineProperty(exports, "__esModule", { value: true });
 3 | class CommandHistory {
 4 |     constructor(history = []) {
 5 |         this.back = history;
 6 |         this.current = -1;
 7 |         this.temp = '';
 8 |     }
 9 |     goBack(current) {
10 |         if (this.current === -1) {
11 |             this.temp = current;
12 |         }
13 |         this.current += 1;
14 |         if (this.current >= this.back.length) {
15 |             this.current = this.back.length - 1;
16 |         }
17 |         if (this.current < 0) {
18 |             this.current = -1;
19 |             return this.temp;
20 |         }
21 |         return this.back[this.current];
22 |     }
23 |     peek(shift) {
24 |         return this.back[this.current - shift];
25 |     }
26 |     goForward() {
27 |         if (this.current <= 0) {
28 |             this.current = -1;
29 |             return this.temp;
30 |         }
31 |         this.current -= 1;
32 |         return this.back[this.current];
33 |     }
34 |     save(current) {
35 |         this.current = -1;
36 |         this.back.unshift(current);
37 |     }
38 |     serialize() {
39 |         return this.back;
40 |     }
41 | }
42 | exports.CommandHistory = CommandHistory;
43 | //# sourceMappingURL=data:application/json;base64,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


--------------------------------------------------------------------------------
/styles/ide-haskell-repl.less:
--------------------------------------------------------------------------------
  1 | // The ui-variables file is provided by base themes provided by Atom.
  2 | //
  3 | // See https://github.com/atom/atom-dark-ui/blob/master/styles/ui-variables.less
  4 | // for a full listing of what's available.
  5 | @import 'ui-variables';
  6 | @import 'octicon-utf-codes';
  7 | 
  8 | .output-icon(@name) {
  9 |   position: relative;
 10 |   padding-left: 1.6em;
 11 |   white-space: pre-wrap;
 12 |   &:before {
 13 |     font-family: 'Octicons Regular';
 14 |     font-weight: normal;
 15 |     font-style: normal;
 16 |     -webkit-font-smoothing: antialiased;
 17 |     text-decoration: none;
 18 |     display: block;
 19 |     text-align: center;
 20 |     content: @@name;
 21 |     position: absolute;
 22 |     left: 0;
 23 |     top: 0;
 24 |     height: 100%;
 25 |     line-height: 1em;
 26 |     width: 1.4em;
 27 |     padding-top: 0.5em;
 28 |     background: @overlay-background-color;
 29 |     border-right: 0.3em solid @overlay-border-color;
 30 |   }
 31 | }
 32 | 
 33 | div.ide-haskell-repl {
 34 |   display: flex;
 35 |   flex-direction: column;
 36 |   .ide-haskell-repl-output {
 37 |     flex-grow: 1;
 38 |     position: relative;
 39 |     overflow-y: scroll;
 40 |     font-family: Menlo, Consolas, 'DejaVu Sans Mono', monospace;
 41 |     pre {
 42 |       font-size: inherit;
 43 |       font-family: inherit;
 44 |       margin-bottom: 0.2em;
 45 |     }
 46 |     .ide-haskell-repl-output-text {
 47 |       .output-icon(chevron-left);
 48 |       background: @input-background-color;
 49 |     }
 50 |     .ide-haskell-repl-input-text {
 51 |       .output-icon(chevron-right);
 52 |       background: @overlay-background-color;
 53 |     }
 54 |     .ide-haskell-repl-stderr {
 55 |       .output-icon(issue-opened);
 56 |       background: @overlay-background-color;
 57 |     }
 58 |     .ide-haskell-repl-input-stdin {
 59 |       .output-icon(playback-play);
 60 |       background: @overlay-background-color;
 61 |     }
 62 |     .ide-haskell-repl-message-text {
 63 |       .output-icon(chevron-left);
 64 |       background: @overlay-background-color;
 65 |     }
 66 |   }
 67 |   .ide-haskell-repl-editor {
 68 |     flex-grow: 0;
 69 |     flex-shrink: 0;
 70 |     position: relative;
 71 |     display: flex;
 72 |     flex-direction: row;
 73 |     .editor-container {
 74 |       flex-grow: 1;
 75 |       flex-shrink: 1;
 76 |       position: relative;
 77 |       atom-text-editor {
 78 |         contain: style;
 79 |       }
 80 |     }
 81 |   }
 82 |   .button-container {
 83 |     display: flex;
 84 |     flex-direction: row;
 85 |     flex-shrink: 0;
 86 |     flex-grow: 0;
 87 |     .repl-prompt {
 88 |       flex-grow: 1;
 89 |       flex-shrink: 1;
 90 |       &.ide-haskell-repl-busy::before {
 91 |         font-family: 'Octicons Regular';
 92 |         content: @hourglass;
 93 |         margin: 0 0.5em;
 94 |       }
 95 |     }
 96 |     button {
 97 |       flex-grow: 0;
 98 |       flex-shrink: 0;
 99 |     }
100 |   }
101 |   .ide-haskell-repl-error {
102 |     flex-grow: 0;
103 |     flex-shrink: 0;
104 |     max-height: 50%;
105 |     overflow: auto;
106 |     background-color: @pane-item-background-color;
107 |     border-top: double 3px @pane-item-border-color;
108 |     & > div {
109 |       border-bottom: solid 2px @pane-item-border-color;
110 |       .ide-haskell-repl-error-error {
111 |         color: @text-color-error;
112 |       }
113 |       .ide-haskell-repl-error-warning {
114 |         color: @text-color-warning;
115 |       }
116 |       .ide-haskell-repl-error-repl {
117 |         color: @text-color-info;
118 |       }
119 |       &:last-of-type {
120 |         border-bottom: none;
121 |       }
122 |       white-space: pre;
123 |       .ide-haskell-repl-error-message {
124 |         margin-left: 2em;
125 |       }
126 |     }
127 |   }
128 |   button {
129 |     flex-shrink: 0;
130 |     flex-grow: 0;
131 |     display: inline-block;
132 |     line-height: 1.8em;
133 |     color: @text-color-subtle;
134 |     border: 1px solid @button-border-color;
135 |     background: fade(@button-background-color, 33%);
136 |     cursor: pointer;
137 |     vertical-align: middle;
138 |     &:active {
139 |       background: transparent;
140 |     }
141 |     font-family: 'Octicons Regular';
142 |     font-weight: normal;
143 |     font-style: normal;
144 |     display: inline-block;
145 |     line-height: 1;
146 |     -webkit-font-smoothing: antialiased;
147 |     text-decoration: none;
148 |     display: block;
149 |     text-align: center;
150 |     font-size: 1.7em;
151 |     &.interrupt:before {
152 |       content: @x;
153 |     }
154 |     &.reload-repeat:before {
155 |       content: @issue-reopened;
156 |     }
157 |     &.clear:before {
158 |       content: @trashcan;
159 |     }
160 |     &.exec:before {
161 |       content: @zap;
162 |       max-height: 2em;
163 |     }
164 |     &.auto-reload-repeat {
165 |       &.enabled {
166 |         color: @text-color-success;
167 |       }
168 |       &:before {
169 |         content: @sync;
170 |       }
171 |     }
172 |   }
173 | }
174 | 


--------------------------------------------------------------------------------
/lib/views/button.js:
--------------------------------------------------------------------------------
 1 | "use strict";
 2 | Object.defineProperty(exports, "__esModule", { value: true });
 3 | const atom_1 = require("atom");
 4 | const etch = require("etch");
 5 | class Button {
 6 |     constructor(props) {
 7 |         this.props = props;
 8 |         this.disposables = new atom_1.CompositeDisposable();
 9 |         this.clslst = new Set();
10 |         this.clslst.add(this.props.cls);
11 |         this.updateState(this.props.state);
12 |         etch.initialize(this);
13 |         this.target = atom.views.getView(this.props.parent.editor);
14 |         this.disposables.add(atom.tooltips.add(this.element, {
15 |             title: this.props.tooltip,
16 |             keyBindingCommand: this.props.command,
17 |             keyBindingTarget: this.target,
18 |         }));
19 |     }
20 |     render() {
21 |         return (etch.dom("button", { className: Array.from(this.clslst.values()).join(' '), on: { click: this.click.bind(this) } }));
22 |     }
23 |     async destroy() {
24 |         await etch.destroy(this);
25 |         this.disposables.dispose();
26 |     }
27 |     async update(props) {
28 |         if (this.props.state === props.state) {
29 |             return Promise.resolve();
30 |         }
31 |         this.props.state = props.state;
32 |         this.updateState(this.props.state);
33 |         return etch.update(this);
34 |     }
35 |     click() {
36 |         if (this.target) {
37 |             atom.commands.dispatch(this.target, this.props.command);
38 |         }
39 |     }
40 |     updateState(state) {
41 |         if (state) {
42 |             this.clslst.add('enabled');
43 |         }
44 |         else {
45 |             this.clslst.delete('enabled');
46 |         }
47 |     }
48 | }
49 | exports.Button = Button;
50 | //# sourceMappingURL=data:application/json;base64,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


--------------------------------------------------------------------------------
/src/ide-haskell-repl.ts:
--------------------------------------------------------------------------------
  1 | import {
  2 |   CompositeDisposable,
  3 |   TWatchEditor,
  4 |   CommandEvent,
  5 |   TextEditor,
  6 |   TextEditorElement,
  7 | } from 'atom'
  8 | import { IdeHaskellReplView, IViewState } from './views/ide-haskell-repl-view'
  9 | import * as UPI from 'atom-haskell-upi'
 10 | import { UPIConsumer } from './upiConsumer'
 11 | import { handlePromise } from './util'
 12 | import { setupGhciWrapper } from './setup-ghci-wrapper'
 13 | 
 14 | export * from './config'
 15 | 
 16 | let disposables: CompositeDisposable
 17 | const editorMap: WeakMap<TextEditor, IdeHaskellReplView> = new WeakMap()
 18 | let resolveUPIPromise: (upi?: UPIConsumer) => void
 19 | let upiPromise: Promise<UPIConsumer | undefined> | undefined
 20 | let resolveWatchEditorPromise: (we: TWatchEditor) => void
 21 | const watchEditorPromise = new Promise<TWatchEditor>((resolve) => {
 22 |   resolveWatchEditorPromise = resolve
 23 | })
 24 | 
 25 | export function activate() {
 26 |   disposables = new CompositeDisposable()
 27 | 
 28 |   // backwards compatibility
 29 |   switch (atom.config.get('ide-haskell-repl').defaultRepl as string) {
 30 |     case 'cabal':
 31 |       atom.config.set('ide-haskell-repl.defaultRepl', 'cabal-v1')
 32 |       break
 33 |     case 'cabal-nix':
 34 |     case 'cabal-new':
 35 |       atom.config.set('ide-haskell-repl.defaultRepl', 'cabal-v2')
 36 |       break
 37 |   }
 38 |   // tslint:disable-next-line:no-floating-promises
 39 |   initUpiPromise()
 40 | 
 41 |   disposables.add(
 42 |     atom.workspace.addOpener((uriToOpen: string) => {
 43 |       const m = uriToOpen.match(/^ide-haskell:\/\/repl\/(.*)$/)
 44 |       // tslint:disable-next-line:strict-type-predicates
 45 |       if (m && m[1] !== undefined) {
 46 |         return createReplView({ uri: m[1], focus: true })
 47 |       }
 48 |       return undefined
 49 |     }),
 50 |   )
 51 | 
 52 |   disposables.add(
 53 |     atom.commands.add(
 54 |       'atom-text-editor',
 55 |       'ide-haskell-repl:toggle',
 56 |       async ({ currentTarget }) => {
 57 |         handlePromise(open(currentTarget.getModel()))
 58 |       },
 59 |     ),
 60 |   )
 61 | 
 62 |   // tslint:disable-next-line: totality-check
 63 |   if (process.platform === 'win32') {
 64 |     disposables.add(
 65 |       atom.commands.add(
 66 |         'atom-workspace',
 67 |         'ide-haskell-repl:setup-ghci-wrapper',
 68 |         setupGhciWrapper,
 69 |       ),
 70 |     )
 71 |   }
 72 | 
 73 |   const commandFunction = (func: string) => ({
 74 |     currentTarget,
 75 |   }: CommandEvent<TextEditorElement>) => {
 76 |     const view = editorMap.get(currentTarget.getModel())
 77 |     if (view) {
 78 |       ;(view[func] as () => void)()
 79 |     }
 80 |   }
 81 | 
 82 |   disposables.add(
 83 |     atom.commands.add('atom-text-editor.ide-haskell-repl', {
 84 |       'ide-haskell-repl:exec-command': commandFunction('execCommand'),
 85 |       'ide-haskell-repl:history-back': commandFunction('historyBack'),
 86 |       'ide-haskell-repl:history-forward': commandFunction('historyForward'),
 87 |       'ide-haskell-repl:ghci-reload': commandFunction('ghciReload'),
 88 |       'ide-haskell-repl:reload-repeat': commandFunction('ghciReloadRepeat'),
 89 |       'ide-haskell-repl:toggle-auto-reload-repeat': commandFunction(
 90 |         'toggleAutoReloadRepeat',
 91 |       ),
 92 |       'ide-haskell-repl:ghci-interrupt': commandFunction('interrupt'),
 93 |       'ide-haskell-repl:clear-output': commandFunction('clear'),
 94 |     }),
 95 |   )
 96 | 
 97 |   const externalCommandFunction = (func: string) => ({
 98 |     currentTarget,
 99 |   }: CommandEvent<TextEditorElement>) => {
100 |     // tslint:disable-next-line:no-floating-promises
101 |     open(currentTarget.getModel(), false).then((model) =>
102 |       (model[func] as () => void)(),
103 |     )
104 |   }
105 | 
106 |   disposables.add(
107 |     atom.commands.add('atom-text-editor:not(.ide-haskell-repl)', {
108 |       'ide-haskell-repl:copy-selection-to-repl-input': ({ currentTarget }) => {
109 |         const ed = currentTarget.getModel()
110 |         const cmd = ed.getLastSelection().getText()
111 |         // tslint:disable-next-line:no-floating-promises
112 |         open(ed).then((model) => model.copyText(cmd))
113 |       },
114 |       'ide-haskell-repl:run-selection-in-repl': ({ currentTarget }) => {
115 |         const ed = currentTarget.getModel()
116 |         const cmd = ed.getLastSelection().getText()
117 |         // tslint:disable-next-line:no-floating-promises
118 |         open(ed, false).then(async (model) => model.runCommand(cmd))
119 |       },
120 |       'ide-haskell-repl:ghci-reload': externalCommandFunction('ghciReload'),
121 |       'ide-haskell-repl:reload-repeat': externalCommandFunction(
122 |         'ghciReloadRepeat',
123 |       ),
124 |       'ide-haskell-repl:toggle-auto-reload-repeat': externalCommandFunction(
125 |         'toggleAutoReloadRepeat',
126 |       ),
127 |     }),
128 |   )
129 | 
130 |   disposables.add(
131 |     atom.menu.add([
132 |       {
133 |         label: 'Haskell IDE',
134 |         submenu: [
135 |           {
136 |             label: 'Open REPL',
137 |             command: 'ide-haskell-repl:toggle',
138 |           },
139 |         ],
140 |       },
141 |     ]),
142 |   )
143 | 
144 |   setTimeout(() => {
145 |     resolveUPIPromise()
146 |   }, 5000)
147 | }
148 | 
149 | export function createReplView(state: IViewState) {
150 |   const upiPromise = initUpiPromise()
151 |   const view = new IdeHaskellReplView({ upiPromise, state, watchEditorPromise })
152 |   editorMap.set(view.editor, view)
153 |   return view
154 | }
155 | 
156 | async function open(
157 |   editor: TextEditor,
158 |   activate = true,
159 | ): Promise<IdeHaskellReplView> {
160 |   const grammar = editor && editor.getGrammar()
161 |   const scope = grammar && grammar.scopeName
162 |   let uri
163 |   if (scope && scope.endsWith('haskell')) {
164 |     uri = editor.getPath()
165 |   } else {
166 |     uri = ''
167 |   }
168 |   return atom.workspace.open(`ide-haskell://repl/${uri}`, {
169 |     split: 'right',
170 |     searchAllPanes: true,
171 |     activatePane: activate,
172 |   }) as Promise<IdeHaskellReplView>
173 | }
174 | 
175 | export function deactivate() {
176 |   upiPromise = undefined
177 |   disposables.dispose()
178 | }
179 | 
180 | export function consumeUPI(register: UPI.IUPIRegistration) {
181 |   const consumer = new UPIConsumer(register)
182 |   disposables.add(consumer)
183 |   resolveUPIPromise(consumer)
184 |   return consumer
185 | }
186 | 
187 | export function autocompleteProvider_3_0_0() {
188 |   return {
189 |     scopeSelector: '.source.haskell',
190 |     disableForScopeSelector: '.source.haskell .comment',
191 |     // getTextEditorSelector: () => 'atom-text-editor.ide-haskell-repl',
192 |     inclusionPriority: 0,
193 |     labels: ['ide-haskell-repl'],
194 |     getSuggestions: async ({
195 |       editor,
196 |       prefix,
197 |     }: {
198 |       editor: TextEditor
199 |       prefix: string
200 |     }) => {
201 |       const view = editorMap.get(editor)
202 |       if (!view) {
203 |         return []
204 |       }
205 |       return view.getCompletions(prefix)
206 |     },
207 |   }
208 | }
209 | 
210 | export function consumeWatchEditor(watchEditor: TWatchEditor) {
211 |   resolveWatchEditorPromise(watchEditor)
212 | }
213 | 
214 | async function initUpiPromise() {
215 |   if (!upiPromise) {
216 |     upiPromise = new Promise<UPIConsumer | undefined>((resolve) => {
217 |       resolveUPIPromise = resolve
218 |     })
219 |   }
220 |   return upiPromise
221 | }
222 | 


--------------------------------------------------------------------------------
/src/upiConsumer.ts:
--------------------------------------------------------------------------------
  1 | import {
  2 |   IUPIInstance,
  3 |   IResultItem,
  4 |   IUPIRegistration,
  5 |   IMessageText,
  6 |   IMessageHTML,
  7 | } from 'atom-haskell-upi'
  8 | import {
  9 |   CompositeDisposable,
 10 |   TextEditor,
 11 |   Range,
 12 |   TextBuffer,
 13 |   Point,
 14 |   PointCompatible,
 15 | } from 'atom'
 16 | import { IdeHaskellReplBase } from './ide-haskell-repl-base'
 17 | import { IdeHaskellReplBg } from './ide-haskell-repl-bg'
 18 | 
 19 | export interface IErrorItem extends IResultItem {
 20 |   _time: number
 21 | }
 22 | 
 23 | export interface BgRec {
 24 |   references: number
 25 |   bg: IdeHaskellReplBg
 26 |   buffers: WeakSet<TextBuffer>
 27 |   disposables: CompositeDisposable
 28 |   dispose(): void
 29 | }
 30 | 
 31 | export class UPIConsumer {
 32 |   private upiRepl: IUPIInstance
 33 |   private upiErrors: IUPIInstance
 34 |   private messages: IErrorItem[] = []
 35 |   private errors: Map<string, IErrorItem[]> = new Map()
 36 |   private disposables = new CompositeDisposable()
 37 |   private maxMessageTime = 10000
 38 |   private bgEditorMap = new Map<string, BgRec>()
 39 | 
 40 |   constructor(register: IUPIRegistration) {
 41 |     this.disposables.add(
 42 |       (this.upiRepl = register({
 43 |         name: 'ide-haskell-repl',
 44 |         messageTypes: {
 45 |           repl: {
 46 |             uriFilter: false,
 47 |             autoScroll: true,
 48 |           },
 49 |         },
 50 |         tooltip: this.shouldShowTooltip.bind(this),
 51 |         events: {
 52 |           onDidSaveBuffer: this.didSaveBuffer.bind(this),
 53 |         },
 54 |       })),
 55 |       (this.upiErrors = register({
 56 |         name: 'ide-haskell-repl::errors',
 57 |       })),
 58 |     )
 59 |   }
 60 | 
 61 |   public dispose() {
 62 |     this.disposables.dispose()
 63 |   }
 64 | 
 65 |   public async getBuilder(): Promise<
 66 |     | {
 67 |         name: 'cabal-v1' | 'stack' | 'cabal-v2' | 'none'
 68 |       }
 69 |     | undefined
 70 |   > {
 71 |     const builder = await this.upiRepl.getOthersConfigParam<{
 72 |       name: 'cabal-v1' | 'stack' | 'cabal-v2' | 'none'
 73 |     }>('ide-haskell-cabal', 'builder')
 74 |     // backwards compatibility
 75 |     switch (builder && (builder.name as string)) {
 76 |       case 'cabal':
 77 |         // tslint:disable-next-line: no-non-null-assertion
 78 |         builder!.name = 'cabal-v1' as const
 79 |         break
 80 |       case 'cabal-nix':
 81 |         // tslint:disable-next-line: no-non-null-assertion
 82 |         builder!.name = 'cabal-v2' as const
 83 |         break
 84 |     }
 85 |     return builder
 86 |   }
 87 | 
 88 |   public setErrors(source: string, errors: IResultItem[]) {
 89 |     this.errors.set(source, this.convert(errors))
 90 |     this.sendAllErrors()
 91 |   }
 92 | 
 93 |   public setMessages(messages: IResultItem[]) {
 94 |     const all = this.convert(messages)
 95 |     this.messages = this.messages.filter(
 96 |       ({ _time }) => Date.now() - _time < this.maxMessageTime,
 97 |     )
 98 |     this.messages.push(...all.filter(({ severity }) => severity === 'repl'))
 99 |     this.upiRepl.setMessages(this.messages)
100 |   }
101 | 
102 |   private convert(xs: IResultItem[]): IErrorItem[] {
103 |     const _time = Date.now()
104 |     return xs.map((x) => ({ ...x, _time }))
105 |   }
106 | 
107 |   private sendAllErrors() {
108 |     let errors: IErrorItem[] = []
109 |     for (const [source, errorArr] of this.errors.entries()) {
110 |       if (
111 |         !atom.config.get('ide-haskell-repl.checkOnSave') &&
112 |         source.startsWith('bg:')
113 |       ) {
114 |         continue
115 |       }
116 |       errors = errors.filter(
117 |         (x) =>
118 |           !errorArr.some(
119 |             (y) =>
120 |               x._time <= y._time &&
121 |               x.context === y.context &&
122 |               compareMessage(x.message, y.message) &&
123 |               comparePosition(x.position, y.position) &&
124 |               x.severity === y.severity,
125 |           ),
126 |       )
127 |       errors.push(...errorArr)
128 |     }
129 |     this.upiErrors.setMessages(errors)
130 |   }
131 | 
132 |   private async shouldShowTooltip(
133 |     editor: TextEditor,
134 |     crange: Range,
135 |     _type: string,
136 |   ) {
137 |     if (!atom.config.get('ide-haskell-repl.showTypes')) {
138 |       return undefined
139 |     }
140 |     const path = editor.getPath()
141 |     if (!path) return undefined
142 |     const buffer = editor.getBuffer()
143 |     const { bg } = await this.getBgRepl(buffer)
144 |     if (!bg) return undefined
145 |     return bg.showTypeAt(path, crange)
146 |   }
147 | 
148 |   private async didSaveBuffer(buffer: TextBuffer) {
149 |     if (
150 |       !atom.config.get('ide-haskell-repl.checkOnSave') &&
151 |       !atom.config.get('ide-haskell-repl.showTypes')
152 |     ) {
153 |       return
154 |     }
155 |     const { bg, isNew } = await this.getBgRepl(buffer)
156 |     if (bg) {
157 |       // no need to reload newly created instance since it reloads on start
158 |       if (isNew) await bg.readyPromise
159 |       else await bg.ghciReload()
160 |     }
161 |   }
162 | 
163 |   private async getBgRepl(buffer: TextBuffer) {
164 |     const path = buffer.getPath()
165 |     if (!path) return { bg: undefined, isNew: false }
166 |     const { cwd, cabal, comp } = await IdeHaskellReplBase.componentFromURI(path)
167 |     const hash = `${cwd.getPath()}::${cabal && cabal.name}::${comp && comp[0]}`
168 |     let bgrec = this.bgEditorMap.get(hash)
169 |     let isNew = false
170 |     if (!bgrec) {
171 |       bgrec = this.createNewBgRepl(hash, path)
172 |       isNew = true
173 |     }
174 |     subscribeToBuffer(bgrec, buffer)
175 |     return { bg: bgrec.bg, isNew }
176 |   }
177 | 
178 |   private createNewBgRepl(hash: string, path: string) {
179 |     const bg = new IdeHaskellReplBg(this, { uri: path })
180 |     const bgrec: BgRec = {
181 |       bg,
182 |       references: 0,
183 |       buffers: new WeakSet(),
184 |       disposables: new CompositeDisposable(),
185 |       dispose: () => {
186 |         this.disposables.delete(bgrec)
187 |         this.bgEditorMap.delete(hash)
188 |         // tslint:disable-next-line:no-floating-promises
189 |         bgrec.bg.destroy()
190 |         bgrec.disposables.dispose()
191 |       },
192 |     }
193 |     this.disposables.add(bgrec)
194 |     this.bgEditorMap.set(hash, bgrec)
195 |     bgrec.disposables.add(
196 |       bg.onDidDestroy(() => {
197 |         bgrec.dispose()
198 |       }),
199 |     )
200 |     return bgrec
201 |   }
202 | }
203 | 
204 | function subscribeToBuffer(rec: BgRec, buffer: TextBuffer) {
205 |   if (rec.buffers.has(buffer)) return
206 |   rec.references++
207 |   rec.buffers.add(buffer)
208 |   rec.disposables.add(
209 |     buffer.onDidDestroy(() => {
210 |       rec.buffers.delete(buffer)
211 |       rec.references--
212 |       if (rec.references === 0) {
213 |         rec.dispose()
214 |       }
215 |     }),
216 |   )
217 | }
218 | 
219 | function comparePosition(x?: PointCompatible, y?: PointCompatible): boolean {
220 |   if (x && y) {
221 |     return Point.fromObject(x).isEqual(y)
222 |   } else {
223 |     return x === y
224 |   }
225 | }
226 | 
227 | function compareMessage(
228 |   x: IErrorItem['message'],
229 |   y: IErrorItem['message'],
230 | ): boolean {
231 |   if (typeof x === 'string' && typeof y === 'string') {
232 |     return x === y
233 |   } else if (isTextMessage(x) && isTextMessage(y)) {
234 |     return x.text === y.text
235 |   } else if (isHTMLMessage(x) && isHTMLMessage(y)) {
236 |     return x.html === y.html
237 |   }
238 |   return false
239 | }
240 | 
241 | function isTextMessage(x: IErrorItem['message']): x is IMessageText {
242 |   return (x as any).text !== undefined
243 | }
244 | 
245 | function isHTMLMessage(x: IErrorItem['message']): x is IMessageHTML {
246 |   return (x as any).text !== undefined
247 | }
248 | 


--------------------------------------------------------------------------------
/src/interactive-process.ts:
--------------------------------------------------------------------------------
  1 | import * as CP from 'child_process'
  2 | import Queue = require('promise-queue')
  3 | import tkill = require('tree-kill')
  4 | import EventEmitter = require('events')
  5 | import { EOL } from 'os'
  6 | 
  7 | if (!Symbol.asyncIterator) {
  8 |   Object.defineProperty(Symbol, 'asyncIterator', {
  9 |     value: Symbol.for('Symbol.asyncIterator'),
 10 |   })
 11 | }
 12 | 
 13 | export type ExitCallback = (exitCode: number | null) => void
 14 | 
 15 | export interface IRequestResult {
 16 |   stdout: string[]
 17 |   stderr: string[]
 18 |   prompt: RegExpMatchArray
 19 | }
 20 | export interface ILineIO {
 21 |   type: 'stdin' | 'stdout' | 'stderr'
 22 |   line: string
 23 | }
 24 | export interface ILinePrompt {
 25 |   type: 'prompt'
 26 |   prompt: RegExpMatchArray
 27 | }
 28 | export type TLineType = ILineIO | ILinePrompt
 29 | export type TLineCallback = (line: TLineType) => void
 30 | 
 31 | function debug(...args: string[]) {
 32 |   if (window['atom-haskell-interactive-process-debug'] === true) {
 33 |     console.debug(...args)
 34 |   }
 35 | }
 36 | 
 37 | export class InteractiveProcess {
 38 |   private process?: CP.ChildProcess
 39 |   private requestQueue: Queue
 40 |   private endPattern: RegExp
 41 |   private events = new EventEmitter()
 42 |   constructor(
 43 |     cmd: string,
 44 |     args: string[],
 45 |     onDidExit: ExitCallback,
 46 |     opts: CP.SpawnOptions,
 47 |     endPattern: RegExp,
 48 |   ) {
 49 |     this.endPattern = endPattern
 50 |     this.requestQueue = new Queue(1, 100)
 51 | 
 52 |     opts.stdio = ['pipe', 'pipe', 'pipe']
 53 | 
 54 |     try {
 55 |       this.process = CP.spawn(cmd, args, opts)
 56 |       this.process.stdout.setMaxListeners(100)
 57 |       this.process.stderr.setMaxListeners(100)
 58 |       this.process.stdout.setEncoding('utf-8')
 59 |       this.process.stderr.setEncoding('utf-8')
 60 | 
 61 |       this.process.on('exit', (code) => {
 62 |         if (code !== 0) {
 63 |           console.error('Process exited abnormally', code)
 64 |         }
 65 |         this.process = undefined
 66 |         onDidExit(code)
 67 |         this.destroy()
 68 |       })
 69 |       this.process.on('error', (err) => {
 70 |         atom.notifications.addError(`Process "${cmd}" failed to start`, {
 71 |           dismissable: true,
 72 |           detail: err.toString(),
 73 |           stack: (err as Error).stack,
 74 |         })
 75 |         this.process = undefined
 76 |         onDidExit(-1)
 77 |         this.destroy()
 78 |       })
 79 |     } catch (error) {
 80 |       atom.notifications.addFatalError('Error spawning REPL', {
 81 |         dismissable: true,
 82 |         stack: error.stack,
 83 |         detail: `Tried to run "${cmd}" with arguments: ${args}`,
 84 |       })
 85 |       this.destroy()
 86 |     }
 87 |   }
 88 | 
 89 |   public async request(
 90 |     command: string,
 91 |     lineCallback?: TLineCallback,
 92 |     endPattern: RegExp = this.endPattern,
 93 |   ): Promise<IRequestResult> {
 94 |     return this.requestQueue.add(async () => {
 95 |       if (!this.process) {
 96 |         throw new Error('Interactive process is not running')
 97 |       }
 98 | 
 99 |       this.process.stdout.pause()
100 |       this.process.stderr.pause()
101 | 
102 |       this.writeStdin(command)
103 |       if (lineCallback) {
104 |         lineCallback({ type: 'stdin', line: command })
105 |       }
106 | 
107 |       const res: IRequestResult = {
108 |         stdout: [],
109 |         stderr: [],
110 |         prompt: [],
111 |       }
112 | 
113 |       const isEnded = () => res.prompt.length > 0 || this.process === undefined
114 | 
115 |       const stdErrLine = (line: string) => {
116 |         if (lineCallback) {
117 |           lineCallback({ type: 'stderr', line })
118 |         }
119 |         res.stderr.push(line)
120 |       }
121 | 
122 |       const stderr = this.process.stderr
123 |       setImmediate(async () => {
124 |         for await (const line of this.readgen(stderr, isEnded)) {
125 |           debug('stderr', line)
126 |           stdErrLine(line)
127 |         }
128 |       })
129 |       let interval = undefined
130 |       try {
131 |         interval = window.setInterval(() => process.activateUvLoop(), 100)
132 |         for await (const line of this.readgen(this.process.stdout, isEnded)) {
133 |           debug('stdout', line)
134 |           const pattern = line.match(endPattern)
135 |           if (pattern) {
136 |             if (lineCallback) {
137 |               lineCallback({ type: 'prompt', prompt: pattern })
138 |             }
139 |             res.prompt = pattern
140 |           } else {
141 |             if (lineCallback) {
142 |               lineCallback({ type: 'stdout', line })
143 |             }
144 |             res.stdout.push(line)
145 |           }
146 |         }
147 |         // tslint:disable-next-line:no-unsafe-any
148 |         const restErr: string = this.process.stderr.read()
149 |         if (restErr) {
150 |           restErr.split('\n').forEach(stdErrLine)
151 |         }
152 |         this.process.stdout.resume()
153 |         this.process.stderr.resume()
154 |         return res
155 |       } catch (e) {
156 |         console.error(e, res)
157 |         atom.notifications.addError(`Process crashed while running request`, {
158 |           detail: `\
159 | stderr:
160 | ${res.stderr.join('\n')}
161 | stdout:
162 | ${res.stdout.join('\n')}
163 | request:
164 | ${command}
165 | `,
166 |           dismissable: true,
167 |           stack: (e as Error).stack,
168 |         })
169 |         throw e
170 |       } finally {
171 |         if (interval !== undefined) window.clearInterval(interval)
172 |       }
173 |     })
174 |   }
175 | 
176 |   public destroy() {
177 |     if (this.process) {
178 |       tkill(this.process.pid, 'SIGTERM')
179 |       this.process = undefined
180 |     }
181 |     this.events.emit('destroyed')
182 |   }
183 | 
184 |   public interrupt() {
185 |     if (this.process) {
186 |       tkill(this.process.pid, 'SIGINT')
187 |     }
188 |   }
189 | 
190 |   public isBusy() {
191 |     return this.requestQueue.getPendingLength() > 0
192 |   }
193 | 
194 |   public writeStdin(str: string) {
195 |     if (!this.process) {
196 |       throw new Error('Interactive process is not running')
197 |     }
198 |     debug('request', str)
199 |     this.process.stdin.write(str)
200 |   }
201 | 
202 |   private async waitReadable(stream: NodeJS.ReadableStream) {
203 |     return new Promise((resolve, reject) => {
204 |       if (!this.process) return reject(new Error('No process'))
205 |       const removeListeners = () => {
206 |         this.events.removeListener('destroyed', rejectError)
207 |         stream.removeListener('readable', resolv)
208 |       }
209 |       const rejectError = () => {
210 |         removeListeners()
211 |         const err = new Error(
212 |           'Process destroyed while awaiting stream readable',
213 |         ) as any
214 |         err.destroyed = true
215 |         reject(err)
216 |       }
217 |       const resolv = () => {
218 |         removeListeners()
219 |         resolve()
220 |       }
221 |       this.events.once('destroyed', rejectError)
222 |       stream.once('readable', resolv)
223 |     })
224 |   }
225 | 
226 |   private async *readgen(out: NodeJS.ReadableStream, isEnded: () => boolean) {
227 |     let buffer = ''
228 |     while (!isEnded()) {
229 |       const read = out.read()
230 |       // tslint:disable-next-line: no-null-keyword strict-type-predicates
231 |       if (read != null) {
232 |         buffer += read
233 |         if (buffer.match(EOL)) {
234 |           const arr = buffer.split(EOL)
235 |           buffer = arr.pop() || ''
236 |           yield* arr
237 |         }
238 |       } else {
239 |         try {
240 |           await this.waitReadable(out)
241 |         } catch (e) {
242 |           if (e.destroyed) {
243 |             console.debug(e)
244 |             return
245 |           }
246 |         }
247 |       }
248 |     }
249 |     if (buffer) {
250 |       out.unshift(buffer)
251 |     }
252 |   }
253 | }
254 | 


--------------------------------------------------------------------------------
/lib/config.js:
--------------------------------------------------------------------------------
 1 | "use strict";
 2 | Object.defineProperty(exports, "__esModule", { value: true });
 3 | exports.config = {
 4 |     defaultRepl: {
 5 |         type: 'string',
 6 |         enum: ['stack', 'cabal-v1', 'ghci', 'cabal-v2'],
 7 |         default: 'ghci',
 8 |         order: 0,
 9 |     },
10 |     stackPath: {
11 |         type: 'string',
12 |         default: 'stack',
13 |         description: 'Path to stack executable',
14 |         order: 10,
15 |     },
16 |     cabalPath: {
17 |         type: 'string',
18 |         default: 'cabal',
19 |         description: 'Path to cabal executable',
20 |         order: 20,
21 |     },
22 |     legacyCabalV1: {
23 |         type: 'boolean',
24 |         default: 'false',
25 |         description: 'Enable if using cabal-install < 2.4.0.0 and wish to use `cabal repl`',
26 |         order: 21,
27 |     },
28 |     ghciPath: {
29 |         type: 'string',
30 |         default: 'ghci',
31 |         description: 'Path to ghci executable',
32 |         order: 30,
33 |     },
34 |     extraArgs: {
35 |         type: 'array',
36 |         default: [],
37 |         description: 'Extra arguments passed to ghci. Comma-separated',
38 |         items: {
39 |             type: 'string',
40 |         },
41 |         order: 40,
42 |     },
43 |     autoReloadRepeat: {
44 |         type: 'boolean',
45 |         default: false,
46 |         description: `Automatically reload and repeat last command on file save.
47 |     This is only the default. You can toggle this per-editor using
48 |     ide-haskell-repl:toggle-auto-reload-repeat command`,
49 |         order: 50,
50 |     },
51 |     maxMessages: {
52 |         type: 'number',
53 |         default: 100,
54 |         minimum: 0,
55 |         description: `Maximum number of ghci messages shown. 0 means unlimited.`,
56 |         order: 60,
57 |     },
58 |     errorsInOutput: {
59 |         type: 'boolean',
60 |         default: true,
61 |         description: `Show interactive errors in output window.`,
62 |         order: 65,
63 |     },
64 |     showTypes: {
65 |         type: 'boolean',
66 |         default: false,
67 |         description: `Show type tooltips in ide-haskell if possible`,
68 |         order: 70,
69 |     },
70 |     checkOnSave: {
71 |         type: 'boolean',
72 |         default: false,
73 |         description: `Reload project in background when file is saved, will effectively
74 |     check for errors`,
75 |         order: 80,
76 |     },
77 |     ghciWrapperPath: {
78 |         type: 'string',
79 |         default: '',
80 |         description: `This is intended to fix the 'interrupt closes ghci' problem
81 |     on Windows -- see README for details. This option has no effect on
82 |     other platforms`,
83 |         order: 999,
84 |     },
85 | };
86 | //# sourceMappingURL=data:application/json;base64,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


--------------------------------------------------------------------------------
/lib/ide-haskell-repl-bg.js:
--------------------------------------------------------------------------------
 1 | "use strict";
 2 | Object.defineProperty(exports, "__esModule", { value: true });
 3 | const atom_1 = require("atom");
 4 | const ide_haskell_repl_base_1 = require("./ide-haskell-repl-base");
 5 | const path = require("path");
 6 | class IdeHaskellReplBg extends ide_haskell_repl_base_1.IdeHaskellReplBase {
 7 |     constructor(consumer, state) {
 8 |         super(Promise.resolve(consumer), state, `bg:${state.uri}`);
 9 |         this.types = [];
10 |         this.gotTypes = this.readyPromise;
11 |     }
12 |     async showTypeAt(uri, inrange) {
13 |         await this.gotTypes;
14 |         const typeRec = this.types.find((tr) => tr !== undefined &&
15 |             tr.uri === uri &&
16 |             atom_1.Range.fromObject(tr.span).containsRange(inrange));
17 |         if (!typeRec) {
18 |             return undefined;
19 |         }
20 |         const { span: range, type: text } = typeRec;
21 |         const highlighter = 'hint.type.haskell';
22 |         return { range, text: { text, highlighter } };
23 |     }
24 |     async destroy() {
25 |         this.types = [];
26 |         return super.destroy();
27 |     }
28 |     async update() {
29 |     }
30 |     async onInitialLoad() {
31 |         await this.ghciReload();
32 |         await super.onInitialLoad();
33 |     }
34 |     async onReload() {
35 |         await (this.gotTypes = this.getAllTypes());
36 |         await super.onReload();
37 |     }
38 |     async getAllTypes() {
39 |         if (!this.ghci) {
40 |             throw new Error('No GHCI instance!');
41 |         }
42 |         if (!atom.config.get('ide-haskell-repl.showTypes'))
43 |             return;
44 |         const { stdout } = await this.ghci.writeLines([':all-types']);
45 |         const cwd = this.cwd
46 |             ? this.cwd
47 |             : await ide_haskell_repl_base_1.IdeHaskellReplBase.getRootDir(this.uri);
48 |         const rx = /^(.*):\((\d+),(\d+)\)-\((\d+),(\d+)\):\s*(.*)$/;
49 |         this.types = stdout.map((line) => {
50 |             const match = line.match(rx);
51 |             if (!match)
52 |                 return undefined;
53 |             return {
54 |                 uri: path.isAbsolute(match[1])
55 |                     ? match[1]
56 |                     : cwd.getFile(match[1]).getPath(),
57 |                 type: match[6],
58 |                 span: [
59 |                     [parseInt(match[2], 10) - 1, parseInt(match[3], 10) - 1],
60 |                     [parseInt(match[4], 10) - 1, parseInt(match[5], 10) - 1],
61 |                 ],
62 |             };
63 |         });
64 |     }
65 | }
66 | exports.IdeHaskellReplBg = IdeHaskellReplBg;
67 | //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaWRlLWhhc2tlbGwtcmVwbC1iZy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9pZGUtaGFza2VsbC1yZXBsLWJnLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBQUEsK0JBQTRCO0FBQzVCLG1FQUlnQztBQUNoQyw2QkFBNEI7QUFXNUIsTUFBYSxnQkFBaUIsU0FBUSwwQ0FBa0I7SUFHdEQsWUFBWSxRQUFxQixFQUFFLEtBQWlCO1FBQ2xELEtBQUssQ0FBQyxPQUFPLENBQUMsT0FBTyxDQUFDLFFBQVEsQ0FBQyxFQUFFLEtBQUssRUFBRSxNQUFNLEtBQUssQ0FBQyxHQUFHLEVBQUUsQ0FBQyxDQUFBO1FBSHBELFVBQUssR0FBbUMsRUFBRSxDQUFBO1FBSWhELElBQUksQ0FBQyxRQUFRLEdBQUcsSUFBSSxDQUFDLFlBQVksQ0FBQTtJQUNuQyxDQUFDO0lBRU0sS0FBSyxDQUFDLFVBQVUsQ0FBQyxHQUFXLEVBQUUsT0FBYztRQUNqRCxNQUFNLElBQUksQ0FBQyxRQUFRLENBQUE7UUFDbkIsTUFBTSxPQUFPLEdBQUcsSUFBSSxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQzdCLENBQUMsRUFBRSxFQUFFLEVBQUUsQ0FDTCxFQUFFLEtBQUssU0FBUztZQUNoQixFQUFFLENBQUMsR0FBRyxLQUFLLEdBQUc7WUFDZCxZQUFLLENBQUMsVUFBVSxDQUFDLEVBQUUsQ0FBQyxJQUFJLENBQUMsQ0FBQyxhQUFhLENBQUMsT0FBTyxDQUFDLENBQ25ELENBQUE7UUFDRCxJQUFJLENBQUMsT0FBTyxFQUFFO1lBQ1osT0FBTyxTQUFTLENBQUE7U0FDakI7UUFDRCxNQUFNLEVBQUUsSUFBSSxFQUFFLEtBQUssRUFBRSxJQUFJLEVBQUUsSUFBSSxFQUFFLEdBQUcsT0FBTyxDQUFBO1FBQzNDLE1BQU0sV0FBVyxHQUFHLG1CQUFtQixDQUFBO1FBQ3ZDLE9BQU8sRUFBRSxLQUFLLEVBQUUsSUFBSSxFQUFFLEVBQUUsSUFBSSxFQUFFLFdBQVcsRUFBRSxFQUFFLENBQUE7SUFDL0MsQ0FBQztJQUVNLEtBQUssQ0FBQyxPQUFPO1FBQ2xCLElBQUksQ0FBQyxLQUFLLEdBQUcsRUFBRSxDQUFBO1FBQ2YsT0FBTyxLQUFLLENBQUMsT0FBTyxFQUFFLENBQUE7SUFDeEIsQ0FBQztJQUVNLEtBQUssQ0FBQyxNQUFNO0lBRW5CLENBQUM7SUFFUyxLQUFLLENBQUMsYUFBYTtRQUMzQixNQUFNLElBQUksQ0FBQyxVQUFVLEVBQUUsQ0FBQTtRQUN2QixNQUFNLEtBQUssQ0FBQyxhQUFhLEVBQUUsQ0FBQTtJQUM3QixDQUFDO0lBRVMsS0FBSyxDQUFDLFFBQVE7UUFDdEIsTUFBTSxDQUFDLElBQUksQ0FBQyxRQUFRLEdBQUcsSUFBSSxDQUFDLFdBQVcsRUFBRSxDQUFDLENBQUE7UUFDMUMsTUFBTSxLQUFLLENBQUMsUUFBUSxFQUFFLENBQUE7SUFDeEIsQ0FBQztJQUVTLEtBQUssQ0FBQyxXQUFXO1FBQ3pCLElBQUksQ0FBQyxJQUFJLENBQUMsSUFBSSxFQUFFO1lBQ2QsTUFBTSxJQUFJLEtBQUssQ0FBQyxtQkFBbUIsQ0FBQyxDQUFBO1NBQ3JDO1FBRUQsSUFBSSxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsR0FBRyxDQUFDLDRCQUE0QixDQUFDO1lBQUUsT0FBTTtRQUMxRCxNQUFNLEVBQUUsTUFBTSxFQUFFLEdBQUcsTUFBTSxJQUFJLENBQUMsSUFBSSxDQUFDLFVBQVUsQ0FBQyxDQUFDLFlBQVksQ0FBQyxDQUFDLENBQUE7UUFDN0QsTUFBTSxHQUFHLEdBQUcsSUFBSSxDQUFDLEdBQUc7WUFDbEIsQ0FBQyxDQUFDLElBQUksQ0FBQyxHQUFHO1lBQ1YsQ0FBQyxDQUFDLE1BQU0sMENBQWtCLENBQUMsVUFBVSxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQTtRQUNqRCxNQUFNLEVBQUUsR0FBRyxnREFBZ0QsQ0FBQTtRQUMzRCxJQUFJLENBQUMsS0FBSyxHQUFHLE1BQU0sQ0FBQyxHQUFHLENBQUMsQ0FBQyxJQUFJLEVBQUUsRUFBRTtZQUMvQixNQUFNLEtBQUssR0FBRyxJQUFJLENBQUMsS0FBSyxDQUFDLEVBQUUsQ0FBQyxDQUFBO1lBQzVCLElBQUksQ0FBQyxLQUFLO2dCQUFFLE9BQU8sU0FBUyxDQUFBO1lBQzVCLE9BQU87Z0JBQ0wsR0FBRyxFQUFFLElBQUksQ0FBQyxVQUFVLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxDQUFDO29CQUM1QixDQUFDLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQztvQkFDVixDQUFDLENBQUMsR0FBRyxDQUFDLE9BQU8sQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxPQUFPLEVBQUU7Z0JBQ25DLElBQUksRUFBRSxLQUFLLENBQUMsQ0FBQyxDQUFDO2dCQUNkLElBQUksRUFBRTtvQkFDSixDQUFDLFFBQVEsQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLEVBQUUsRUFBRSxDQUFDLEdBQUcsQ0FBQyxFQUFFLFFBQVEsQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLEVBQUUsRUFBRSxDQUFDLEdBQUcsQ0FBQyxDQUFDO29CQUN4RCxDQUFDLFFBQVEsQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLEVBQUUsRUFBRSxDQUFDLEdBQUcsQ0FBQyxFQUFFLFFBQVEsQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLEVBQUUsRUFBRSxDQUFDLEdBQUcsQ0FBQyxDQUFDO2lCQUN6RDthQUNhLENBQUE7UUFDbEIsQ0FBQyxDQUFDLENBQUE7SUFDSixDQUFDO0NBQ0Y7QUFyRUQsNENBcUVDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUmFuZ2UgfSBmcm9tICdhdG9tJ1xuaW1wb3J0IHtcbiAgSUNvbnRlbnRJdGVtLFxuICBJZGVIYXNrZWxsUmVwbEJhc2UsXG4gIElWaWV3U3RhdGUsXG59IGZyb20gJy4vaWRlLWhhc2tlbGwtcmVwbC1iYXNlJ1xuaW1wb3J0ICogYXMgcGF0aCBmcm9tICdwYXRoJ1xuaW1wb3J0IHsgVVBJQ29uc3VtZXIgfSBmcm9tICcuL3VwaUNvbnN1bWVyJ1xuXG5leHBvcnQgeyBJVmlld1N0YXRlLCBJQ29udGVudEl0ZW0gfVxuXG5leHBvcnQgaW50ZXJmYWNlIElUeXBlUmVjb3JkIHtcbiAgdXJpOiBzdHJpbmdcbiAgdHlwZTogc3RyaW5nXG4gIHNwYW46IFtbbnVtYmVyLCBudW1iZXJdLCBbbnVtYmVyLCBudW1iZXJdXVxufVxuXG5leHBvcnQgY2xhc3MgSWRlSGFza2VsbFJlcGxCZyBleHRlbmRzIElkZUhhc2tlbGxSZXBsQmFzZSB7XG4gIHByaXZhdGUgdHlwZXM6IEFycmF5PElUeXBlUmVjb3JkIHwgdW5kZWZpbmVkPiA9IFtdXG4gIHByaXZhdGUgZ290VHlwZXM6IFByb21pc2U8dm9pZD5cbiAgY29uc3RydWN0b3IoY29uc3VtZXI6IFVQSUNvbnN1bWVyLCBzdGF0ZTogSVZpZXdTdGF0ZSkge1xuICAgIHN1cGVyKFByb21pc2UucmVzb2x2ZShjb25zdW1lciksIHN0YXRlLCBgYmc6JHtzdGF0ZS51cml9YClcbiAgICB0aGlzLmdvdFR5cGVzID0gdGhpcy5yZWFkeVByb21pc2VcbiAgfVxuXG4gIHB1YmxpYyBhc3luYyBzaG93VHlwZUF0KHVyaTogc3RyaW5nLCBpbnJhbmdlOiBSYW5nZSkge1xuICAgIGF3YWl0IHRoaXMuZ290VHlwZXNcbiAgICBjb25zdCB0eXBlUmVjID0gdGhpcy50eXBlcy5maW5kKFxuICAgICAgKHRyKSA9PlxuICAgICAgICB0ciAhPT0gdW5kZWZpbmVkICYmXG4gICAgICAgIHRyLnVyaSA9PT0gdXJpICYmXG4gICAgICAgIFJhbmdlLmZyb21PYmplY3QodHIuc3BhbikuY29udGFpbnNSYW5nZShpbnJhbmdlKSxcbiAgICApXG4gICAgaWYgKCF0eXBlUmVjKSB7XG4gICAgICByZXR1cm4gdW5kZWZpbmVkXG4gICAgfVxuICAgIGNvbnN0IHsgc3BhbjogcmFuZ2UsIHR5cGU6IHRleHQgfSA9IHR5cGVSZWNcbiAgICBjb25zdCBoaWdobGlnaHRlciA9ICdoaW50LnR5cGUuaGFza2VsbCdcbiAgICByZXR1cm4geyByYW5nZSwgdGV4dDogeyB0ZXh0LCBoaWdobGlnaHRlciB9IH1cbiAgfVxuXG4gIHB1YmxpYyBhc3luYyBkZXN0cm95KCkge1xuICAgIHRoaXMudHlwZXMgPSBbXVxuICAgIHJldHVybiBzdXBlci5kZXN0cm95KClcbiAgfVxuXG4gIHB1YmxpYyBhc3luYyB1cGRhdGUoKSB7XG4gICAgLy8gbm9vcFxuICB9XG5cbiAgcHJvdGVjdGVkIGFzeW5jIG9uSW5pdGlhbExvYWQoKSB7XG4gICAgYXdhaXQgdGhpcy5naGNpUmVsb2FkKCkgLy8gcmVxdWlyZWQgdG8gY29sbGVjdCB0eXBlc1xuICAgIGF3YWl0IHN1cGVyLm9uSW5pdGlhbExvYWQoKVxuICB9XG5cbiAgcHJvdGVjdGVkIGFzeW5jIG9uUmVsb2FkKCkge1xuICAgIGF3YWl0ICh0aGlzLmdvdFR5cGVzID0gdGhpcy5nZXRBbGxUeXBlcygpKVxuICAgIGF3YWl0IHN1cGVyLm9uUmVsb2FkKClcbiAgfVxuXG4gIHByb3RlY3RlZCBhc3luYyBnZXRBbGxUeXBlcygpOiBQcm9taXNlPHZvaWQ+IHtcbiAgICBpZiAoIXRoaXMuZ2hjaSkge1xuICAgICAgdGhyb3cgbmV3IEVycm9yKCdObyBHSENJIGluc3RhbmNlIScpXG4gICAgfVxuICAgIC8vIGRvbid0IHdhc3RlIHRpbWUgaWYgZG9uJ3QgbmVlZCB0b1xuICAgIGlmICghYXRvbS5jb25maWcuZ2V0KCdpZGUtaGFza2VsbC1yZXBsLnNob3dUeXBlcycpKSByZXR1cm5cbiAgICBjb25zdCB7IHN0ZG91dCB9ID0gYXdhaXQgdGhpcy5naGNpLndyaXRlTGluZXMoWyc6YWxsLXR5cGVzJ10pXG4gICAgY29uc3QgY3dkID0gdGhpcy5jd2RcbiAgICAgID8gdGhpcy5jd2RcbiAgICAgIDogYXdhaXQgSWRlSGFza2VsbFJlcGxCYXNlLmdldFJvb3REaXIodGhpcy51cmkpXG4gICAgY29uc3QgcnggPSAvXiguKik6XFwoKFxcZCspLChcXGQrKVxcKS1cXCgoXFxkKyksKFxcZCspXFwpOlxccyooLiopJC9cbiAgICB0aGlzLnR5cGVzID0gc3Rkb3V0Lm1hcCgobGluZSkgPT4ge1xuICAgICAgY29uc3QgbWF0Y2ggPSBsaW5lLm1hdGNoKHJ4KVxuICAgICAgaWYgKCFtYXRjaCkgcmV0dXJuIHVuZGVmaW5lZFxuICAgICAgcmV0dXJuIHtcbiAgICAgICAgdXJpOiBwYXRoLmlzQWJzb2x1dGUobWF0Y2hbMV0pXG4gICAgICAgICAgPyBtYXRjaFsxXVxuICAgICAgICAgIDogY3dkLmdldEZpbGUobWF0Y2hbMV0pLmdldFBhdGgoKSxcbiAgICAgICAgdHlwZTogbWF0Y2hbNl0sXG4gICAgICAgIHNwYW46IFtcbiAgICAgICAgICBbcGFyc2VJbnQobWF0Y2hbMl0sIDEwKSAtIDEsIHBhcnNlSW50KG1hdGNoWzNdLCAxMCkgLSAxXSxcbiAgICAgICAgICBbcGFyc2VJbnQobWF0Y2hbNF0sIDEwKSAtIDEsIHBhcnNlSW50KG1hdGNoWzVdLCAxMCkgLSAxXSxcbiAgICAgICAgXSxcbiAgICAgIH0gYXMgSVR5cGVSZWNvcmRcbiAgICB9KVxuICB9XG59XG4iXX0=


--------------------------------------------------------------------------------
/lib/setup-ghci-wrapper.js:
--------------------------------------------------------------------------------
 1 | "use strict";
 2 | Object.defineProperty(exports, "__esModule", { value: true });
 3 | const crypto_1 = require("crypto");
 4 | const atom_1 = require("atom");
 5 | async function setupGhciWrapper() {
 6 |     const downloadUrl = 'https://github.com/atom-haskell/win-ghci-wrapper/releases/download/v0.0.2/ghci-wrapper.exe';
 7 |     const expectedDigest = '4663295d71a5057dee41945a52d39ed61fcd8830';
 8 |     try {
 9 |         atom.notifications.addInfo('GHCi Wrapper setup started...');
10 |         const buf = await downloadFile(downloadUrl);
11 |         checkHash(buf, expectedDigest);
12 |         const filePath = await writeFile(buf);
13 |         atom.config.set('ide-haskell-repl.ghciWrapperPath', filePath);
14 |         atom.notifications.addSuccess('GHCi Wrapper setup finished!');
15 |     }
16 |     catch (e) {
17 |         if (e != null) {
18 |             atom.notifications.addFatalError('GHCi wrapper setup failed', {
19 |                 stack: e.stack,
20 |                 detail: e.message,
21 |                 dismissable: true,
22 |             });
23 |         }
24 |     }
25 | }
26 | exports.setupGhciWrapper = setupGhciWrapper;
27 | async function downloadFile(url) {
28 |     const result = await window.fetch(url, {
29 |         redirect: 'follow',
30 |     });
31 |     if (!result.ok) {
32 |         atom.notifications.addError('Getting ghci-wrapper.exe failed', {
33 |             detail: result.statusText,
34 |             dismissable: true,
35 |         });
36 |         throw undefined;
37 |     }
38 |     return Buffer.from(await result.arrayBuffer());
39 | }
40 | function checkHash(buf, expected) {
41 |     const hash = crypto_1.createHash('sha1');
42 |     hash.update(buf);
43 |     const digest = hash.digest('hex');
44 |     if (digest !== expected) {
45 |         atom.notifications.addError('Got ghci-wrapper.exe, but hash check failed!', {
46 |             detail: `Expected ${expected} but got ${digest}`,
47 |             dismissable: true,
48 |         });
49 |         throw undefined;
50 |     }
51 | }
52 | async function writeFile(buf) {
53 |     const configDir = new atom_1.Directory(atom.getConfigDirPath());
54 |     const subdir = configDir.getSubdirectory('ide-haskell-repl');
55 |     if (!(await subdir.exists())) {
56 |         if (!(await subdir.create())) {
57 |             atom.notifications.addError('Failed to create directory for ghci-wrapper', {
58 |                 detail: subdir.getPath(),
59 |                 dismissable: true,
60 |             });
61 |             throw undefined;
62 |         }
63 |     }
64 |     const file = subdir.getFile('ghci-wrapper.exe');
65 |     const stream = file.createWriteStream();
66 |     try {
67 |         await new Promise((resolve, reject) => {
68 |             stream.on('error', reject);
69 |             stream.write(buf, (error) => {
70 |                 stream.off('error', reject);
71 |                 if (error != null)
72 |                     reject(error);
73 |                 else
74 |                     resolve();
75 |             });
76 |         });
77 |     }
78 |     finally {
79 |         stream.close();
80 |     }
81 |     return file.getPath();
82 | }
83 | //# sourceMappingURL=data:application/json;base64,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


--------------------------------------------------------------------------------
/lib/ghci.js:
--------------------------------------------------------------------------------
 1 | "use strict";
 2 | Object.defineProperty(exports, "__esModule", { value: true });
 3 | const atom_haskell_utils_1 = require("atom-haskell-utils");
 4 | const os_1 = require("os");
 5 | const interactive_process_1 = require("./interactive-process");
 6 | const Queue = require("promise-queue");
 7 | class GHCI {
 8 |     constructor(opts) {
 9 |         this.commandQueue = new Queue(1, 100);
10 |         const endPattern = /^#~IDEHASKELLREPL~(.*)~#$/;
11 |         const { cwd, atomPath, command, args, onExit } = opts;
12 |         this.onDidExit = onExit;
13 |         if (process.platform === 'win32') {
14 |             const spawnArgs = [command, ...args];
15 |             const cmdexe = atom.config.get('ide-haskell-repl.ghciWrapperPath');
16 |             if (cmdexe) {
17 |                 spawnArgs.unshift('"' + cmdexe + '"');
18 |             }
19 |             this.process = new interactive_process_1.InteractiveProcess('chcp 65001 && ', spawnArgs, this.didExit.bind(this), { cwd, shell: true }, endPattern);
20 |         }
21 |         else {
22 |             this.process = new interactive_process_1.InteractiveProcess(command, args, this.didExit.bind(this), { cwd }, endPattern);
23 |         }
24 |         this.readyPromise = this.request(`:set editor \"${atomPath}\" --wait${os_1.EOL}` +
25 |             `:set prompt2 \"\"${os_1.EOL}` +
26 |             `:set prompt-cont \"\"${os_1.EOL}` +
27 |             `:set +c${os_1.EOL}` +
28 |             `:set prompt \"\\n#~IDEHASKELLREPL~%s~#\\n\"${os_1.EOL}`);
29 |     }
30 |     async waitReady() {
31 |         return this.readyPromise;
32 |     }
33 |     isBusy() {
34 |         return this.commandQueue.getPendingLength() > 0;
35 |     }
36 |     async load(uri, callback) {
37 |         return this.request(`:load ${atom_haskell_utils_1.hsEscapeString(uri)}${os_1.EOL}`, callback);
38 |     }
39 |     async reload(callback) {
40 |         return this.request(`:reload${os_1.EOL}`, callback);
41 |     }
42 |     async interrupt() {
43 |         if (this.process) {
44 |             if (atom.config.get('ide-haskell-repl.ghciWrapperPath') &&
45 |                 process.platform === 'win32') {
46 |                 this.process.writeStdin('\x03');
47 |             }
48 |             else {
49 |                 this.process.interrupt();
50 |             }
51 |         }
52 |     }
53 |     async writeLines(lines, callback) {
54 |         return this.request(`:{${os_1.EOL}${lines.join(os_1.EOL)}${os_1.EOL}:}${os_1.EOL}`, callback);
55 |     }
56 |     writeRaw(raw) {
57 |         this.process.writeStdin(raw);
58 |     }
59 |     async sendCompletionRequest() {
60 |         if (this.isBusy())
61 |             return undefined;
62 |         return this.process.request(`:complete repl \"\"${os_1.EOL}`);
63 |     }
64 |     destroy() {
65 |         this.process.destroy();
66 |     }
67 |     didExit(code) {
68 |         this.onDidExit(code);
69 |         this.destroy();
70 |     }
71 |     async request(command, lineCallback) {
72 |         return this.commandQueue.add(async () => this.process.request(command, lineCallback));
73 |     }
74 | }
75 | exports.GHCI = GHCI;
76 | //# sourceMappingURL=data:application/json;base64,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


--------------------------------------------------------------------------------
/CHANGELOG.md:
--------------------------------------------------------------------------------
  1 | ## 0.11.1
  2 | 
  3 | -   Spin event loop while waiting for repl output
  4 | 
  5 |     This should improve responsiveness in some cases.
  6 | 
  7 | -   Fix autocomplete box positioning
  8 | 
  9 | ## 0.11.0
 10 | 
 11 | -   Bump atom-haskell-utils
 12 | 
 13 |     This should allow the package to work with cabalfiles up to 3.2, but it's a little experimental. Please open issues if stuff breaks with "Atom-Haskell core error".
 14 | 
 15 | ## 0.10.2
 16 | 
 17 | -   Fix dangling ghci instances
 18 | 
 19 | ## 0.10.1
 20 | 
 21 | -   Report ghci destruction on debug log, not as error
 22 | -   Avoid infinite recursion on bg repl destruction
 23 | 
 24 | ## 0.10.0
 25 | 
 26 | -   Simplify error parsing somewhat
 27 | -   Fix duplicate error filtering
 28 | -   Colorize error severity in error div
 29 | -   Option to put errors in main repl output
 30 | 
 31 | ## 0.9.7
 32 | 
 33 | -   Add run code button
 34 | 
 35 | ## 0.9.5
 36 | 
 37 | -   Make error div selectable\/copyable
 38 | -   Update repl view when changing editor font size\/family
 39 | 
 40 | ## 0.9.4
 41 | 
 42 | -   Enable setup-ghci-wrapper command on windows
 43 | 
 44 | ## 0.9.3
 45 | 
 46 | -   Fix and clean-up wrapper set-up code
 47 | 
 48 | ## 0.9.2
 49 | 
 50 | -   Add command to setup ghci-wrapper
 51 | 
 52 | ## 0.9.1
 53 | 
 54 | -   Fix interrupt when using ghci-wrapper
 55 | -   Relax autoscroll condition
 56 | 
 57 | ## 0.9.0
 58 | 
 59 | -   Reorder initialization to fix prompt bug
 60 | -   Bump dependencies & cabal-install 3.0 compatibility
 61 | 
 62 | ## 0.8.7
 63 | 
 64 | -   Fix type collection on initial load
 65 | 
 66 | ## 0.8.6
 67 | 
 68 | -   Optimize type collection a little bit
 69 | 
 70 | ## 0.8.5
 71 | 
 72 | -   Don't relativize absolute paths in messages
 73 | 
 74 | ## 0.8.4
 75 | 
 76 | -   Minor fixes, reload GHCI on no type (fixes no type tooltips until saved)
 77 | 
 78 | ## 0.8.3
 79 | 
 80 | -   Update dependencies
 81 | -   Properly dispose of crashed background processes
 82 | -   Better spawn errors and crash handling
 83 | 
 84 | ## 0.8.2
 85 | 
 86 | -   Fixed opening repl outside of a source file
 87 | -   Handle tabs in cabalfile more gracefully
 88 | 
 89 |     Note: tabs are forbidden in Cabalfiles, most of the ecosystem can't
 90 |     handle those. `stack` replaces tabs with spaces, but spews warnings.
 91 |     Other tools just silently fail. Please don't use tabs in cabalfiles.
 92 | 
 93 | -   Fix button state initialization
 94 | 
 95 |     Toggle buttons are now displayed correctly across Atom restarts
 96 | 
 97 | -   Bump dependencies
 98 | 
 99 | ## 0.8.1
100 | 
101 | -   More careful asyncIterator definition
102 | -   Avoid extraneous reload
103 | -   Use atom-ts-spec-runner
104 | 
105 | ## 0.8.0
106 | 
107 | -   Use reference-counting to track background REPL processes
108 | 
109 |     This avoids leaking REPL processes. This wasn't a big issue, since
110 |     only one process per Cabal component is spawned, but no point in
111 |     wasting resources.
112 | 
113 | -   More robust tracking of load/reload in REPL
114 | 
115 |     Manual loading/reloading via `:reload`, `:load` and `:edit` is now
116 |     tracked.
117 | 
118 | -   Set editor to `atom --wait`
119 | 
120 |     This is mostly useful with newer Atom versions, where `--wait`
121 |     actually waits before associated editor is closed
122 | 
123 | -   Better compilation error tracking and reporting
124 | 
125 |     Fixes \#65
126 | 
127 | -   Fixed show type ("absolutize" relative paths)
128 | 
129 |     GHCi 8.2.2 is somewhat inconsistent with how it gives file paths for
130 |     `:all-types`. This problem is fixed.
131 | 
132 | -   Better reporting for startup errors
133 | -   Support for cabal new-repl
134 | 
135 | ## 0.7.16
136 | 
137 | -   Add busy indicator
138 | -   Fix stdin input not showing up (\#62)
139 | -   Fix spec runner
140 | -   Pin typescript version
141 | -   Bump dependencies
142 | 
143 | ## 0.7.15
144 | 
145 | -   Fix error clear/show races, fix reload command
146 | 
147 | ## 0.7.14
148 | 
149 | -   Do not allow input before REPL is initialized
150 | -   Clear errors on reload
151 | 
152 | ## 0.7.13
153 | 
154 | -   Don't send raw stdin if ghci is busy with autocompletion request
155 | 
156 | ## 0.7.12
157 | 
158 | -   Display stdin input straight away; tweak style a bit
159 | 
160 | ## 0.7.11
161 | 
162 | -   Prettier sources
163 | -   Fix spec, Travis
164 | -   Simplify focus retention, allow selecting output
165 | -   Don't try to watch editor if repl view is destroyed
166 | -   Remove repl editor registration in atom.textEditors
167 | 
168 | ## 0.7.10
169 | 
170 | -   Atom 1.23 support (repl autocompletion broken)
171 | -   Dispose of repl's TextEditor registration
172 | 
173 | ## 0.7.9
174 | 
175 | -   Try hard to maintain editor focus
176 | -   Update licensing information in README
177 | -   Bump typings
178 | 
179 | ## 0.7.8
180 | 
181 | -   Add tslib to dependencies
182 | 
183 | ## 0.7.7
184 | 
185 | -   Bump Atom version
186 | -   Try to focus text editor on repl creation; restore text editor focus
187 |     on restart
188 | -   New typings; update deps; bump es target
189 | -   Added david-dm badge
190 | 
191 | ## 0.7.6
192 | 
193 | -   Bump atom-haskell-utils (getComponentsFromFile bug)
194 | 
195 | ## 0.7.5
196 | 
197 | -   Don't use --main-is, broken on new stack versions
198 | -   Updates to lints, typings, minor fixes
199 | 
200 | ## 0.7.4
201 | 
202 | -   Unset continuation prompt (GHC 8.2 compatibility)
203 | -   Fix error rendering in absence of ide-haskell
204 | 
205 | ## 0.7.3
206 | 
207 | -   Better reporting of startup errors
208 | 
209 | ## 0.7.2
210 | 
211 | -   Fix EOL on Windows
212 | 
213 | ## 0.7.1
214 | 
215 | -   Fallback on default repl in case of UPI-reladted errors
216 | -   Enforce code style
217 | -   Update typings
218 | 
219 | ## 0.7.0
220 | 
221 | -   Rewrite in TypeScript
222 | -   Use etch UI
223 | -   Migrate to UPI 0.3
224 | -   Updates for Atom 1.19
225 | -   Bump min. Atom version to 1.19
226 | 
227 | ## 0.6.0
228 | 
229 | -   Collect error messages
230 | -   Add reload-repeat button
231 | -   Refactor adding buttons
232 | -   Button tooltips
233 | -   Toggle autoReloadRepeat button
234 | -   Serialize autoReloadRepeat
235 | -   Add some repl-context commands
236 | -   Some error handling for runCommand
237 | -   Hide load/reload messages
238 | -   Minimal indication that auto-reload-repeat is active
239 | -   Common code, DRY
240 | -   Factor autoReloadRepeat into replView
241 | -   Add reload to editor context
242 | -   Report pre-start errors
243 | 
244 | ## 0.5.2
245 | 
246 | -   Use atom-highlight for highlighting
247 | 
248 | ## 0.5.1
249 | 
250 | -   Merge remote-tracking branch 'origin/atom-1.13'
251 | -   s/target/currentTarget/
252 | -   Bump engine version
253 | -   Atom 1.13 updates
254 | 
255 | ## 0.5.0
256 | 
257 | -   GHCi-powered autocompletion in REPL input (by @yaeti)
258 | 
259 | ## 0.4.9
260 | 
261 | -   Default output fonts
262 | 
263 | ## 0.4.8
264 | 
265 | -   Fix selection commands
266 | 
267 | ## 0.4.7
268 | 
269 | -   Merge pull request \#43 from soiamsoNG/patch-1
270 | -   Quote the path (soiamsoNG)
271 | 
272 | ## 0.4.6
273 | 
274 | -   Fix \#40 (error panel shrinking)
275 | 
276 | ## 0.4.5
277 | 
278 | -   Fix some formatting issues on Windows
279 | -   \[README\] reword "using on windows" a bit
280 | 
281 | ## 0.4.4
282 | 
283 | -   Band-aid some Windows-specific issues
284 | 
285 | ## 0.4.3
286 | 
287 | -   Revert "First attempt at fixing win32 interrupt"
288 | 
289 | ## 0.4.2
290 | 
291 | -   First attempt at fixing win32 interrupt
292 | -   Fix LICENSE date
293 | -   Fix license
294 | 
295 | ## 0.4.1
296 | 
297 | -   Only store history back buffer
298 | 
299 | ## 0.4.0
300 | 
301 | -   Resolve UPI promise on timeout
302 | -   Trim errDiv output
303 | -   Initial support for (de)serialization
304 | -   Removed old code
305 | -   Better output handling, minor bugfixes
306 | 
307 | ## 0.3.1
308 | 
309 | -   Filter out ANSI escape sequences from REPL output
310 | 
311 | ## 0.3.0
312 | 
313 | -   Auto reload-repeat
314 | -   Add reload-repeat command, some focus/scope fixes on commands
315 | -   Don't save `:reload` in command history
316 | 
317 | ## 0.2.1
318 | 
319 | -   Remove debug string
320 | 
321 | ## 0.2.0
322 | 
323 | -   Add commands to copy/run selected text from current editor
324 | 
325 | ## 0.1.11
326 | 
327 | -   Add interrupt command
328 | 
329 | ## 0.1.10
330 | 
331 | -   Allow n as newline separator on Win32 in addition to rn
332 | 
333 | ## 0.1.9
334 | 
335 | -   Switch to child\_process
336 | 
337 | ## 0.1.8
338 | 
339 | -   Really fix \#33
340 | 
341 | ## 0.1.7
342 | 
343 | -   Fix \#33
344 | -   Revert "Tentative fix for \#33"
345 | 
346 | ## 0.1.6
347 | 
348 | -   Tentative fix for \#33
349 | 
350 | ## 0.1.5
351 | 
352 | -   Fix \#32
353 | 
354 | ## 0.1.4
355 | 
356 | -   Make repl input soft-wrapped
357 | 
358 | ## 0.1.3
359 | 
360 | -   Fix some issues, use UPI 0.2.0
361 | 
362 | ## 0.1.2
363 | 
364 | -   Close repl if no builder selected
365 | 
366 | ## 0.1.1
367 | 
368 | -   Fix \#28
369 | -   Hack to suppress ac-p, ahu bump
370 | -   Readme update
371 | -   Update package status in README
372 | 
373 | ## 0.1.0
374 | 
375 | -   Auto-switch based on ide-haskell-cabal builder
376 | 
377 | ## 0.0.23
378 | 
379 | -   Fix \#23
380 | 
381 | ## 0.0.22
382 | 
383 | -   AHS bump
384 | -   Atom-haskell-utils bump
385 | -   Set settings order
386 | 
387 | ## 0.0.21
388 | 
389 | -   Set ghc process encoding
390 | -   Use n instead of ␊
391 | 
392 | ## 0.0.20
393 | 
394 | -   Ability to supply stdin
395 | -   Interrupt button
396 | 
397 | ## 0.0.19
398 | 
399 | -   Quick fix for \#18
400 | 
401 | ## 0.0.18
402 | 
403 | -   Special handling of components for stack
404 | -   atom-haskell-utils version bump
405 | 
406 | ## 0.0.17
407 | 
408 | -   BUGFIX: atom-haskell-utils bump
409 | 
410 | ## 0.0.16
411 | 
412 | -   Fix isDirectory bug
413 | 
414 | ## 0.0.15
415 | 
416 | -   Use synchronous call to getComponentFromFile(Sync)
417 | -   Remove unneeded import
418 | 
419 | ## 0.0.14
420 | 
421 | -   Fix \#2 (cabal component selection)
422 | 
423 | ## 0.0.13
424 | 
425 | -   Fix \#1
426 | 
427 | ## 0.0.12
428 | 
429 | -   Fix \#14
430 | 
431 | ## 0.0.11
432 | 
433 | -   Log errors on exit, log stderr in console
434 | 
435 | ## 0.0.10
436 | 
437 | -   Merge pull request \#13 from jjay/master
438 | -   Focus repl input on repl focus
439 | 
440 | ## 0.0.9
441 | 
442 | -   Work around Atom not displaying keybindings
443 | 
444 | ## 0.0.8
445 | 
446 | -   Use keymaps for default bindings, OSX bindings
447 | 
448 | ## 0.0.7
449 | 
450 | -   Use ide-haskell's UPI for error/warning output
451 | 
452 | ## 0.0.6
453 | 
454 | -   Get Atom path from process.execPath
455 | 
456 | ## 0.0.5
457 | 
458 | -   Rebindable commands, reload command
459 | 
460 | ## 0.0.4
461 | 
462 | -   Handle some errors
463 | 
464 | ## 0.0.3
465 | 
466 | -   Remove redundant @\[0\] and better errDiv styling
467 | 
468 | ## 0.0.2
469 | 
470 | -   Remove bogus serialization
471 | -   Activate on Haskell sources only
472 | 
473 | ## 0.0.1
474 | 
475 | -   Initial prototype release
476 | 


--------------------------------------------------------------------------------
/src/views/ide-haskell-repl-view.tsx:
--------------------------------------------------------------------------------
  1 | import { CompositeDisposable, TextEditor, Point, TWatchEditor } from 'atom'
  2 | import highlightSync = require('atom-highlight')
  3 | import etch = require('etch')
  4 | 
  5 | import {
  6 |   IContentItem,
  7 |   IdeHaskellReplBase,
  8 |   IViewState,
  9 |   IErrorItem,
 10 |   IRequestResult,
 11 | } from '../ide-haskell-repl-base'
 12 | import { Button } from './button'
 13 | import { Editor } from './editor'
 14 | import { UPIConsumer } from '../upiConsumer'
 15 | import { handlePromise } from '../util'
 16 | 
 17 | export { IViewState, IContentItem, IRequestResult }
 18 | 
 19 | const termEscapeRx = /\x1B\[([0-9]{1,2}(;[0-9]{1,2})?)?[m|K]/g
 20 | 
 21 | export interface IViewStateOutput extends IViewState {
 22 |   deserializer: string
 23 | }
 24 | 
 25 | export interface IProps extends JSX.Props {
 26 |   upiPromise: Promise<UPIConsumer | undefined>
 27 |   state: IViewState
 28 |   watchEditorPromise: Promise<TWatchEditor>
 29 | }
 30 | 
 31 | export interface UpdateProps extends JSX.Props {
 32 |   outputFontFamily: string
 33 |   outputFontSize: number
 34 | }
 35 | 
 36 | // tslint:disable-next-line:no-unsafe-any
 37 | export class IdeHaskellReplView extends IdeHaskellReplBase
 38 |   implements JSX.ElementClass {
 39 |   public refs!: {
 40 |     output: HTMLElement
 41 |     editor: Editor
 42 |   }
 43 |   public editor: TextEditor
 44 |   private fontSettings: UpdateProps
 45 |   private disposables: CompositeDisposable
 46 |   private initialized: boolean = false
 47 |   constructor(public props: IProps) {
 48 |     super(props.upiPromise, props.state, `view:${props.state.uri}`)
 49 |     this.disposables = new CompositeDisposable()
 50 | 
 51 |     this.editor = atom.workspace.buildTextEditor({
 52 |       lineNumberGutterVisible: false,
 53 |       softWrapped: true,
 54 |     })
 55 |     atom.grammars.assignLanguageMode(this.editor.getBuffer(), 'source.haskell')
 56 | 
 57 |     this.fontSettings = {
 58 |       outputFontSize: atom.config.get('editor.fontSize'),
 59 |       outputFontFamily: atom.config.get('editor.fontFamily'),
 60 |     }
 61 |     this.disposables.add(
 62 |       atom.workspace.observeTextEditors((editor: TextEditor) => {
 63 |         if (editor.getPath() === this.uri) {
 64 |           this.disposables.add(
 65 |             editor.onDidSave(() => {
 66 |               if (this.autoReloadRepeat) {
 67 |                 // tslint:disable-next-line:no-floating-promises
 68 |                 this.ghciReloadRepeat()
 69 |               }
 70 |             }),
 71 |           )
 72 |         }
 73 |       }),
 74 |       atom.config.onDidChange('editor.fontSize', ({ newValue }) => {
 75 |         handlePromise(this.update({ outputFontSize: newValue }))
 76 |       }),
 77 |       atom.config.onDidChange('editor.fontFamily', ({ newValue }) => {
 78 |         handlePromise(this.update({ outputFontFamily: newValue }))
 79 |       }),
 80 |     )
 81 | 
 82 |     etch.initialize(this)
 83 | 
 84 |     if (this.props.state.focus) setImmediate(() => this.focus())
 85 |     this.registerEditor().catch((e: Error) => {
 86 |       atom.notifications.addError(e.toString(), {
 87 |         detail: e.stack,
 88 |         dismissable: true,
 89 |       })
 90 |     })
 91 |   }
 92 | 
 93 |   public focus = () => {
 94 |     this.refs && this.refs.editor && this.refs.editor.element.focus()
 95 |   }
 96 | 
 97 |   public async execCommand() {
 98 |     if (!this.initialized) return undefined
 99 |     const inp = this.editor.getBuffer().getText()
100 |     this.editor.setText('')
101 |     if (this.ghci && this.ghci.isBusy()) {
102 |       this.messages.push({
103 |         text: inp,
104 |         hl: false,
105 |         cls: 'ide-haskell-repl-input-stdin',
106 |       })
107 |       this.ghci.writeRaw(inp)
108 |       await this.update()
109 |       return undefined
110 |     } else {
111 |       this.history.save(inp)
112 |       return this.runCommand(inp)
113 |     }
114 |   }
115 | 
116 |   public copyText(command: string) {
117 |     this.editor.setText(command)
118 |     atom.views.getView(this.editor).focus()
119 |   }
120 | 
121 |   public historyBack() {
122 |     const current = this.editor.getText()
123 |     this.editor.setText(this.history.goBack(current))
124 |   }
125 | 
126 |   public historyForward() {
127 |     this.editor.setText(this.history.goForward())
128 |   }
129 | 
130 |   public clear() {
131 |     this.messages = []
132 |     this.clearErrors()
133 |     // tslint:disable-next-line:no-floating-promises
134 |     this.update()
135 |   }
136 | 
137 |   public getURI() {
138 |     return `ide-haskell://repl/${this.uri}`
139 |   }
140 | 
141 |   public getTitle() {
142 |     return `REPL: ${this.uri}`
143 |   }
144 | 
145 |   public async destroy() {
146 |     if (this.destroyed) return
147 |     await etch.destroy(this)
148 |     this.disposables.dispose()
149 |     return super.destroy()
150 |   }
151 | 
152 |   public serialize(): IViewStateOutput {
153 |     return {
154 |       deserializer: 'IdeHaskellReplView',
155 |       uri: this.uri,
156 |       content: this.messages,
157 |       history: this.history.serialize(),
158 |       autoReloadRepeat: this.autoReloadRepeat,
159 |       focus: this.isFocused(),
160 |     }
161 |   }
162 | 
163 |   public async update(props?: Partial<UpdateProps>) {
164 |     if (props) Object.assign(this.fontSettings, props)
165 | 
166 |     const atEnd =
167 |       !!this.refs &&
168 |       this.refs.output.scrollTop + this.refs.output.clientHeight >=
169 |         this.refs.output.scrollHeight - this.fontSettings.outputFontSize
170 |     const focused = this.isFocused()
171 |     await etch.update(this)
172 |     if (atEnd) {
173 |       this.refs.output.scrollTop =
174 |         this.refs.output.scrollHeight - this.refs.output.clientHeight
175 |     }
176 |     if (focused) {
177 |       this.focus()
178 |     }
179 |   }
180 | 
181 |   public render() {
182 |     return (
183 |       // tslint:disable:no-unsafe-any
184 |       <div
185 |         className="ide-haskell-repl"
186 |         tabIndex="-1"
187 |         on={{ focus: this.focus }}
188 |       >
189 |         <div
190 |           ref="output"
191 |           key="output"
192 |           className="ide-haskell-repl-output native-key-bindings"
193 |           tabIndex="-1"
194 |           style={{
195 |             fontSize: `${this.fontSettings.outputFontSize}px`,
196 |             fontFamily: this.fontSettings.outputFontFamily,
197 |           }}
198 |         >
199 |           {this.renderOutput()}
200 |         </div>
201 |         {this.renderErrDiv()}
202 |         <div key="buttons" className="button-container">
203 |           {this.renderPrompt()}
204 |           <Button
205 |             cls="reload-repeat"
206 |             tooltip="Reload file and repeat last command"
207 |             command="ide-haskell-repl:reload-repeat"
208 |             parent={this}
209 |           />
210 |           <Button
211 |             cls="auto-reload-repeat"
212 |             tooltip="Toggle reload-repeat on file save"
213 |             command="ide-haskell-repl:toggle-auto-reload-repeat"
214 |             state={this.autoReloadRepeat}
215 |             parent={this}
216 |           />
217 |           <Button
218 |             cls="interrupt"
219 |             tooltip="Interrupt current computation"
220 |             command="ide-haskell-repl:ghci-interrupt"
221 |             parent={this}
222 |           />
223 |           <Button
224 |             cls="clear"
225 |             tooltip="Clear output"
226 |             command="ide-haskell-repl:clear-output"
227 |             parent={this}
228 |           />
229 |         </div>
230 |         <div key="editor" className="ide-haskell-repl-editor">
231 |           <div className="editor-container">
232 |             <Editor ref="editor" element={atom.views.getView(this.editor)} />
233 |           </div>
234 |           <Button
235 |             cls="exec"
236 |             tooltip="Run code"
237 |             command="ide-haskell-repl:exec-command"
238 |             parent={this}
239 |           />
240 |         </div>
241 |       </div>
242 |       // tslint:enable:no-unsafe-any
243 |     )
244 |   }
245 | 
246 |   protected async onInitialLoad() {
247 |     if (!this.ghci) {
248 |       throw new Error('No GHCI instance!')
249 |     }
250 |     await super.onInitialLoad()
251 |     const res = await this.ghci.load(this.uri)
252 |     this.prompt = res.prompt[1]
253 |     this.errorsFromStderr(res.stderr)
254 |     this.initialized = true
255 |   }
256 | 
257 |   private renderErrDiv() {
258 |     if (!this.upi) {
259 |       return (
260 |         <div
261 |           className="native-key-bindings ide-haskell-repl-error"
262 |           tabIndex="-1"
263 |         >
264 |           {this.renderErrors()}
265 |         </div>
266 |       )
267 |     } else {
268 |       // tslint:disable-next-line: no-null-keyword
269 |       return null
270 |     }
271 |   }
272 | 
273 |   private renderErrors() {
274 |     return this.errors.map((err) => this.renderError(err))
275 |   }
276 | 
277 |   private renderError(error: IErrorItem) {
278 |     const pos = error.position ? Point.fromObject(error.position) : undefined
279 |     const uri = error.uri || '<interactive>'
280 |     const positionText = pos ? `${uri}: ${pos.row + 1}, ${pos.column + 1}` : uri
281 |     const context = error.context || ''
282 |     return (
283 |       <div>
284 |         {positionText}:{' '}
285 |         <span className={`ide-haskell-repl-error-${error.severity}`}>
286 |           {error.severity}
287 |         </span>
288 |         : {context}
289 |         <div class="ide-haskell-repl-error-message">{error.message}</div>
290 |       </div>
291 |     )
292 |   }
293 | 
294 |   private renderPrompt() {
295 |     const busyClass =
296 |       this.ghci && this.ghci.isBusy() ? ' ide-haskell-repl-busy' : ''
297 |     return (
298 |       // tslint:disable-next-line:no-unsafe-any
299 |       <div class={`repl-prompt${busyClass}`}>
300 |         {this.prompt || ''}
301 |         &gt;
302 |       </div>
303 |     )
304 |   }
305 | 
306 |   private renderOutput() {
307 |     const maxMsg = atom.config.get('ide-haskell-repl.maxMessages')
308 |     if (maxMsg > 0) {
309 |       this.messages = this.messages.slice(-maxMsg)
310 |     }
311 |     return this.messages.map((msg: IContentItem) => {
312 |       const { text, cls, hl } = msg
313 |       let { hlcache } = msg
314 |       const cleanText = text.replace(termEscapeRx, '')
315 |       if (hl) {
316 |         if (!hlcache) {
317 |           hlcache = msg.hlcache = highlightSync({
318 |             fileContents: cleanText,
319 |             scopeName: 'source.haskell',
320 |             nbsp: false,
321 |           })
322 |         }
323 |         return (
324 |           // tslint:disable-next-line:no-unsafe-any
325 |           <pre className={cls} innerHTML={hlcache} />
326 |         )
327 |       } else {
328 |         // tslint:disable-next-line:no-unsafe-any
329 |         return <pre className={cls}>{cleanText}</pre>
330 |       }
331 |     })
332 |   }
333 | 
334 |   private isFocused() {
335 |     return (
336 |       !!this.refs &&
337 |       !!document.activeElement &&
338 |       this.refs.editor.element.contains(document.activeElement)
339 |     )
340 |   }
341 | 
342 |   private async registerEditor() {
343 |     const we = await this.props.watchEditorPromise
344 |     if (this.destroyed) return
345 |     this.disposables.add(we(this.editor, ['ide-haskell-repl']))
346 |   }
347 | }
348 | 


--------------------------------------------------------------------------------
/src/ide-haskell-repl-base.ts:
--------------------------------------------------------------------------------
  1 | import * as Util from 'atom-haskell-utils'
  2 | import { filter } from 'fuzzaldrin'
  3 | 
  4 | import { CommandHistory } from './command-history'
  5 | import { GHCI, IRequestResult } from './ghci'
  6 | import * as UPI from 'atom-haskell-upi'
  7 | import * as AtomTypes from 'atom'
  8 | import { UPIConsumer } from './upiConsumer'
  9 | import { isAbsolute, normalize } from 'path'
 10 | import { handlePromise, getText } from './util'
 11 | 
 12 | export { IRequestResult }
 13 | 
 14 | export interface IViewState {
 15 |   uri?: string
 16 |   history?: string[]
 17 |   autoReloadRepeat?: boolean
 18 |   content?: IContentItem[]
 19 |   focus?: boolean
 20 | }
 21 | 
 22 | export interface IContentItem {
 23 |   text: string
 24 |   cls: string
 25 |   hl?: boolean
 26 |   hlcache?: string
 27 | }
 28 | 
 29 | export interface IErrorItem extends UPI.IResultItem {
 30 |   _time: number
 31 | }
 32 | 
 33 | async function readCabalFile(
 34 |   cabalFile: AtomTypes.File,
 35 | ): Promise<string | undefined> {
 36 |   const cabalContents = await cabalFile.read()
 37 |   if (cabalContents === null) return undefined
 38 |   const noTabs = cabalContents.replace(/\t/g, '        ')
 39 |   if (noTabs !== cabalContents) {
 40 |     atom.notifications.addWarning(
 41 |       'Tabs found in Cabalfile, replacing with 8 spaces',
 42 |       {
 43 |         detail:
 44 |           'Tabs are not allowed as indentation characters in Cabalfiles due to ' +
 45 |           'a missing standard interpretation of tab width. Tabs have been ' +
 46 |           'automatically replaced by 8 spaces as per Haskell report standard, ' +
 47 |           'but it is advised to avoid using tabulation in Cabalfile.',
 48 |         dismissable: true,
 49 |       },
 50 |     )
 51 |   }
 52 |   return noTabs
 53 | }
 54 | 
 55 | async function getCabalFile(
 56 |   rootDir: AtomTypes.Directory,
 57 | ): Promise<AtomTypes.File[]> {
 58 |   const cont = await new Promise<Array<AtomTypes.Directory | AtomTypes.File>>(
 59 |     (resolve, reject) =>
 60 |       rootDir.getEntries((error, contents) => {
 61 |         if (error) {
 62 |           reject(error)
 63 |         } else {
 64 |           resolve(contents)
 65 |         }
 66 |       }),
 67 |   )
 68 |   return cont.filter(
 69 |     (file) => file.isFile() && file.getBaseName().endsWith('.cabal'),
 70 |   ) as AtomTypes.File[]
 71 | }
 72 | 
 73 | async function parseCabalFile(
 74 |   cabalFile: AtomTypes.File,
 75 |   cwd: AtomTypes.Directory,
 76 |   uri: string | undefined,
 77 | ): Promise<{ cabal?: Util.IDotCabal; comps?: string[] }> {
 78 |   const cabalContents = await readCabalFile(cabalFile)
 79 |   if (cabalContents === undefined) return {}
 80 |   const cabal = await Util.parseDotCabal(cabalContents)
 81 |   let comps: string[] | undefined
 82 |   if (uri !== undefined) {
 83 |     comps = await Util.getComponentFromFile(cabalContents, cwd.relativize(uri))
 84 |   }
 85 |   return { cabal: cabal === null ? undefined : cabal, comps }
 86 | }
 87 | 
 88 | export abstract class IdeHaskellReplBase {
 89 |   public readonly readyPromise: Promise<void>
 90 |   protected ghci?: GHCI
 91 |   protected cwd?: AtomTypes.Directory
 92 |   protected prompt: string = ''
 93 |   protected upi?: UPIConsumer
 94 |   protected messages: IContentItem[]
 95 |   protected errors: IErrorItem[] = []
 96 |   protected _autoReloadRepeat: boolean
 97 |   protected history: CommandHistory
 98 |   protected uri: string
 99 |   protected destroyed = false
100 |   private emitter = new AtomTypes.Emitter<{ destroyed: void }>()
101 | 
102 |   constructor(
103 |     upiPromise: Promise<UPIConsumer | undefined>,
104 |     {
105 |       uri,
106 |       content,
107 |       history,
108 |       autoReloadRepeat = atom.config.get('ide-haskell-repl.autoReloadRepeat'),
109 |     }: IViewState,
110 |     protected readonly errorSrouce: string,
111 |   ) {
112 |     this.uri = uri || ''
113 |     this.history = new CommandHistory(history)
114 |     this._autoReloadRepeat = !!autoReloadRepeat
115 | 
116 |     this.messages = content || []
117 | 
118 |     this.readyPromise = this.initialize(upiPromise)
119 |   }
120 | 
121 |   public static async getRootDir(uri: string) {
122 |     return Util.getRootDir(uri)
123 |   }
124 | 
125 |   public static async componentFromURI(uri: string) {
126 |     const cwd = await IdeHaskellReplBase.getRootDir(uri)
127 |     const [cabalFile] = await getCabalFile(cwd)
128 | 
129 |     let comp: string | undefined
130 |     let cabal: Util.IDotCabal | undefined
131 |     if (cabalFile) {
132 |       const parsed = await parseCabalFile(cabalFile, cwd, cwd.relativize(uri))
133 |       if (parsed.comps) comp = parsed.comps[0]
134 |       if (parsed.cabal) cabal = parsed.cabal
135 |     }
136 |     return { cwd, comp, cabal }
137 |   }
138 | 
139 |   public abstract async update(props?: any): Promise<void>
140 | 
141 |   public onDidDestroy(callback: () => void) {
142 |     return this.emitter.on('destroyed', callback)
143 |   }
144 | 
145 |   public toggleAutoReloadRepeat() {
146 |     this.autoReloadRepeat = !this.autoReloadRepeat
147 |   }
148 | 
149 |   public async runCommand(command: string) {
150 |     if (!this.ghci) {
151 |       throw new Error('No GHCI instance!')
152 |     }
153 |     const inp = command.split('\n')
154 |     const res = await this.ghci.writeLines(inp, (lineInfo) => {
155 |       switch (lineInfo.type) {
156 |         case 'stdin':
157 |           lineInfo.line &&
158 |             this.messages.push({
159 |               text: inp.join('\n'),
160 |               hl: true,
161 |               cls: 'ide-haskell-repl-input-text',
162 |             })
163 |           break
164 |         case 'stdout':
165 |           lineInfo.line &&
166 |             this.messages.push({
167 |               text: lineInfo.line,
168 |               hl: true,
169 |               cls: 'ide-haskell-repl-output-text',
170 |             })
171 |           break
172 |         case 'prompt':
173 |           this.prompt = lineInfo.prompt[1]
174 |           break
175 |         default:
176 |           break
177 |       }
178 |       // tslint:disable-next-line:no-floating-promises
179 |       this.update()
180 |     })
181 |     // tslint:disable-next-line:no-floating-promises
182 |     this.update()
183 |     if (command.trim().startsWith(':l')) await this.onLoad()
184 |     else if (command.trim().startsWith(':r')) await this.onReload()
185 |     else if (command.trim().startsWith(':e')) await this.onReload()
186 |     this.errorsFromStderr(res.stderr)
187 |     return res
188 |   }
189 | 
190 |   public async ghciReload() {
191 |     if (!this.ghci) {
192 |       throw new Error('No GHCI instance!')
193 |     }
194 |     const { prompt, stderr } = await this.ghci.reload()
195 |     this.prompt = prompt[1]
196 |     // tslint:disable-next-line:no-floating-promises
197 |     this.update()
198 |     await this.onReload()
199 |     return !this.errorsFromStderr(stderr)
200 |   }
201 | 
202 |   public async ghciReloadRepeat() {
203 |     if (await this.ghciReload()) {
204 |       const command = this.history.peek(-1)
205 |       if (command) {
206 |         return this.runCommand(command)
207 |       }
208 |     }
209 |     return undefined
210 |   }
211 | 
212 |   public set autoReloadRepeat(autoReloadRepeat: boolean) {
213 |     this._autoReloadRepeat = autoReloadRepeat
214 |     // tslint:disable-next-line:no-floating-promises
215 |     this.update()
216 |   }
217 | 
218 |   public get autoReloadRepeat() {
219 |     return this._autoReloadRepeat
220 |   }
221 | 
222 |   public interrupt() {
223 |     if (!this.ghci) {
224 |       throw new Error('No GHCI instance!')
225 |     }
226 |     // tslint:disable-next-line:no-floating-promises
227 |     this.ghci.interrupt()
228 |   }
229 | 
230 |   public async getCompletions(prefix: string) {
231 |     if (!prefix.trim()) {
232 |       return []
233 |     }
234 |     if (!this.ghci) {
235 |       throw new Error('No GHCI instance!')
236 |     }
237 |     const res = await this.ghci.sendCompletionRequest()
238 |     if (!res) return undefined
239 |     res.stdout.shift()
240 |     return filter(res.stdout, prefix).map((text) => ({
241 |       text: text.slice(1, -1),
242 |     }))
243 |   }
244 | 
245 |   public clearErrors() {
246 |     this.setErrors([])
247 |   }
248 | 
249 |   protected async onInitialLoad() {
250 |     return this.onLoad()
251 |   }
252 | 
253 |   protected async onReload() {
254 |     return this.onLoad()
255 |   }
256 | 
257 |   protected async onLoad() {
258 |     return this.clearErrors()
259 |   }
260 | 
261 |   protected async destroy() {
262 |     if (this.destroyed) return
263 |     this.destroyed = true
264 |     this.emitter.emit('destroyed')
265 |     this.clearErrors()
266 |     if (this.ghci) {
267 |       this.ghci.destroy()
268 |     }
269 |   }
270 | 
271 |   protected async initialize(upiPromise: Promise<UPIConsumer | undefined>) {
272 |     this.upi = await upiPromise
273 |     if (!this.upi) {
274 |       return this.runREPL()
275 |     }
276 | 
277 |     try {
278 |       const builder = await this.upi.getBuilder()
279 |       return await this.runREPL(builder && builder.name)
280 |     } catch (e) {
281 |       const error = e as Error
282 |       if (error) {
283 |         atom.notifications.addFatalError(error.toString(), {
284 |           detail: error.toString(),
285 |           dismissable: true,
286 |           stack: error.stack,
287 |         })
288 |       }
289 |       atom.notifications.addWarning(
290 |         "ide-haskell-repl: Couldn't get builder. Falling back to default REPL",
291 |         {
292 |           dismissable: true,
293 |         },
294 |       )
295 |       return this.runREPL()
296 |     }
297 |   }
298 | 
299 |   protected async runREPL(
300 |     inbuilder?: 'cabal-v1' | 'stack' | 'cabal-v2' | 'none',
301 |   ) {
302 |     const builder = inbuilder || atom.config.get('ide-haskell-repl.defaultRepl')
303 |     if (!builder) throw new Error(`Default REPL not specified`)
304 | 
305 |     const { cwd, comp, cabal } = await IdeHaskellReplBase.componentFromURI(
306 |       this.uri,
307 |     )
308 |     this.cwd = cwd
309 | 
310 |     let commandPath: string
311 |     let commandArgs: string[]
312 |     let extraArgs: (x: string) => string
313 |     switch (builder) {
314 |       case 'cabal-v1':
315 |         commandPath = atom.config.get('ide-haskell-repl.cabalPath')
316 |         commandArgs = atom.config.get('ide-haskell-repl').legacyCabalV1
317 |           ? ['repl']
318 |           : ['v1-repl']
319 |         extraArgs = (x: string) => `--ghc-option=${x}`
320 |         break
321 |       case 'cabal-v2':
322 |         commandPath = atom.config.get('ide-haskell-repl.cabalPath')
323 |         commandArgs = ['v2-repl']
324 |         extraArgs = (x: string) => `--ghc-option=${x}`
325 |         break
326 |       case 'stack':
327 |         commandPath = atom.config.get('ide-haskell-repl.stackPath')
328 |         commandArgs = ['ghci']
329 |         extraArgs = (x: string) => `--ghci-options="${x}"`
330 |         break
331 |       case 'ghci':
332 |       case 'none':
333 |         commandPath = atom.config.get('ide-haskell-repl.ghciPath')
334 |         commandArgs = []
335 |         extraArgs = (x) => x
336 |         break
337 |       default:
338 |         throw new Error(`Unknown builder ${builder}`)
339 |     }
340 | 
341 |     const extraArgsList = atom.config.get('ide-haskell-repl.extraArgs') || []
342 |     commandArgs.push(...extraArgsList.map(extraArgs))
343 | 
344 |     if (comp && cabal) {
345 |       if (builder === 'stack') {
346 |         const compc = comp.startsWith('lib:') ? 'lib' : comp
347 |         commandArgs.push(`${cabal.name}:${compc}`)
348 |       } else {
349 |         commandArgs.push(comp)
350 |       }
351 |     }
352 | 
353 |     this.ghci = new GHCI({
354 |       atomPath: process.execPath,
355 |       command: commandPath,
356 |       args: commandArgs,
357 |       cwd: this.cwd.getPath(),
358 |       onExit: async () => this.destroy(),
359 |     })
360 | 
361 |     const initres = await this.ghci.waitReady()
362 |     this.prompt = initres.prompt[1]
363 |     await this.onInitialLoad()
364 |     this.errorsFromStderr(initres.stderr, true)
365 |     return this.update()
366 |   }
367 | 
368 |   protected errorsFromStderr(
369 |     stderr: string[],
370 |     filterInitWarnings = false,
371 |   ): boolean {
372 |     const noInitWarnings = filterInitWarnings
373 |       ? (x: IErrorItem | undefined): x is IErrorItem =>
374 |           x !== undefined &&
375 |           !(
376 |             x.severity === 'repl' &&
377 |             getText(x.message).match(
378 |               /^Some flags have not been recognized: (?:(?:prompt2|prompt-cont),\s*)+\s*/,
379 |             )
380 |           )
381 |       : (x: IErrorItem | undefined): x is IErrorItem => x !== undefined
382 |     return this.appendErrors(
383 |       stderr
384 |         .filter((x) => !/^\s*\d* \|/.test(x))
385 |         .join('\n')
386 |         .split(/\n(?=\S)/)
387 |         .map(this.parseMessage)
388 |         .filter(noInitWarnings),
389 |     )
390 |   }
391 | 
392 |   protected unindentMessage(message: string): string {
393 |     let lines = message.split('\n').filter((x) => !x.match(/^\s*$/))
394 |     let minIndent: number | undefined
395 |     for (const line of lines) {
396 |       const match = line.match(/^\s*/)
397 |       if (match) {
398 |         const lineIndent = match[0].length
399 |         if (!minIndent || lineIndent < minIndent) {
400 |           minIndent = lineIndent
401 |         }
402 |       }
403 |     }
404 |     if (minIndent !== undefined) {
405 |       const mi = minIndent
406 |       lines = lines.map((line) => line.slice(mi))
407 |     }
408 |     return lines.join('\n')
409 |   }
410 | 
411 |   protected parseMessage = (raw: string): IErrorItem | undefined => {
412 |     if (!this.cwd) {
413 |       return undefined
414 |     }
415 |     const matchLoc = /^(.+):(\d+):(\d+):(?: (\w+):)?[ \t]*(\[[^\]]+\])?[ \t]*\n?([^]*)/
416 |     if (raw && raw.trim() !== '') {
417 |       const matched = raw.match(matchLoc)
418 |       if (matched) {
419 |         const [filec, line, col, rawTyp, context, msg]: Array<
420 |           string | undefined
421 |         > = matched.slice(1)
422 |         let typ: UPI.TSeverity = rawTyp ? rawTyp.toLowerCase() : 'error'
423 |         let file: string | undefined
424 |         if (filec === '<interactive>') {
425 |           file = undefined
426 |           typ = 'repl'
427 |         } else {
428 |           file = filec
429 |         }
430 | 
431 |         return {
432 |           uri: file
433 |             ? isAbsolute(file)
434 |               ? normalize(file)
435 |               : this.cwd.getFile(file).getPath()
436 |             : undefined,
437 |           position: [
438 |             parseInt(line as string, 10) - 1,
439 |             parseInt(col as string, 10) - 1,
440 |           ],
441 |           message: {
442 |             text: this.unindentMessage(
443 |               (msg as string & { trimRight(): string }).trimRight(),
444 |             ),
445 |             highlighter: 'hint.message.haskell',
446 |           },
447 |           context,
448 |           severity: typ,
449 |           _time: Date.now(),
450 |         }
451 |       } else {
452 |         return {
453 |           message: raw,
454 |           severity: 'repl',
455 |           _time: Date.now(),
456 |         }
457 |       }
458 |     } else {
459 |       return undefined
460 |     }
461 |   }
462 | 
463 |   private appendErrors(errors: IErrorItem[]): boolean {
464 |     let hasErrors = false
465 |     let newMessages = false
466 |     let newErrors = false
467 |     for (const error of errors) {
468 |       const dupIdx = this.errors.findIndex((x) => isSameError(error, x))
469 |       if (dupIdx >= 0) {
470 |         if (this.errors[dupIdx]._time <= error._time) {
471 |           this.errors[dupIdx]._time = error._time
472 |         }
473 |       } else {
474 |         this.errors.push(error)
475 |       }
476 |       if (error.severity === 'error') hasErrors = true
477 |       if (error.severity === 'repl') newMessages = true
478 |       else newErrors = true
479 |     }
480 |     const errMessages = errors.filter(({ severity }) => severity === 'repl')
481 |     if (atom.config.get('ide-haskell-repl.errorsInOutput')) {
482 |       for (const m of errMessages) {
483 |         this.messages.push({
484 |           text: getText(m.message),
485 |           cls: 'ide-haskell-repl-stderr',
486 |         })
487 |       }
488 |     }
489 |     this.setErrors(this.errors, newErrors, newMessages)
490 |     return hasErrors
491 |   }
492 | 
493 |   private setErrors(
494 |     errors: IErrorItem[],
495 |     newErrors = true,
496 |     newMessages = true,
497 |   ) {
498 |     this.errors = errors
499 |     if (this.upi) {
500 |       if (newMessages) {
501 |         this.upi.setMessages(
502 |           this.errors.filter(({ severity }) => severity === 'repl'),
503 |         )
504 |       }
505 |       if (newErrors) {
506 |         this.upi.setErrors(
507 |           this.errorSrouce,
508 |           this.errors.filter(({ severity }) => severity !== 'repl'),
509 |         )
510 |       }
511 |     } else {
512 |       if (atom.config.get('ide-haskell-repl.errorsInOutput')) {
513 |         this.errors = this.errors.filter(({ severity }) => severity !== 'repl')
514 |       }
515 |       const now = Date.now()
516 |       this.errors = this.errors.filter(
517 |         (x) => x.uri !== undefined || now - x._time < 3000,
518 |       )
519 |     }
520 |     handlePromise(this.update())
521 |   }
522 | }
523 | 
524 | function isSameError(e1: IErrorItem, e2: IErrorItem) {
525 |   const sameContext = e1.context === e2.context
526 |   const samePos =
527 |     e1.position &&
528 |     e2.position &&
529 |     AtomTypes.Point.fromObject(e1.position).isEqual(e2.position)
530 |   const sameSeverity = e1.severity === e2.severity
531 |   const sameUri = e1.uri === e2.uri
532 |   const sameMessage = isSameMessage(e1.message, e2.message)
533 |   return sameContext && samePos && sameSeverity && sameUri && sameMessage
534 | }
535 | 
536 | function isSameMessage(m1: UPI.TMessage, m2: UPI.TMessage) {
537 |   if (typeof m1 === 'string' || typeof m2 === 'string') {
538 |     return m1 === m2
539 |   } else if ('html' in m1 && 'html' in m2) {
540 |     return m1.html === m2.html
541 |   } else if ('text' in m1 && 'text' in m2) {
542 |     return m1.text === m2.text && m1.highlighter === m2.highlighter
543 |   } else {
544 |     return false
545 |   }
546 | }
547 | 


--------------------------------------------------------------------------------
/lib/ide-haskell-repl.js:
--------------------------------------------------------------------------------
  1 | "use strict";
  2 | Object.defineProperty(exports, "__esModule", { value: true });
  3 | const tslib_1 = require("tslib");
  4 | const atom_1 = require("atom");
  5 | const ide_haskell_repl_view_1 = require("./views/ide-haskell-repl-view");
  6 | const upiConsumer_1 = require("./upiConsumer");
  7 | const util_1 = require("./util");
  8 | const setup_ghci_wrapper_1 = require("./setup-ghci-wrapper");
  9 | tslib_1.__exportStar(require("./config"), exports);
 10 | let disposables;
 11 | const editorMap = new WeakMap();
 12 | let resolveUPIPromise;
 13 | let upiPromise;
 14 | let resolveWatchEditorPromise;
 15 | const watchEditorPromise = new Promise((resolve) => {
 16 |     resolveWatchEditorPromise = resolve;
 17 | });
 18 | function activate() {
 19 |     disposables = new atom_1.CompositeDisposable();
 20 |     switch (atom.config.get('ide-haskell-repl').defaultRepl) {
 21 |         case 'cabal':
 22 |             atom.config.set('ide-haskell-repl.defaultRepl', 'cabal-v1');
 23 |             break;
 24 |         case 'cabal-nix':
 25 |         case 'cabal-new':
 26 |             atom.config.set('ide-haskell-repl.defaultRepl', 'cabal-v2');
 27 |             break;
 28 |     }
 29 |     initUpiPromise();
 30 |     disposables.add(atom.workspace.addOpener((uriToOpen) => {
 31 |         const m = uriToOpen.match(/^ide-haskell:\/\/repl\/(.*)$/);
 32 |         if (m && m[1] !== undefined) {
 33 |             return createReplView({ uri: m[1], focus: true });
 34 |         }
 35 |         return undefined;
 36 |     }));
 37 |     disposables.add(atom.commands.add('atom-text-editor', 'ide-haskell-repl:toggle', async ({ currentTarget }) => {
 38 |         util_1.handlePromise(open(currentTarget.getModel()));
 39 |     }));
 40 |     if (process.platform === 'win32') {
 41 |         disposables.add(atom.commands.add('atom-workspace', 'ide-haskell-repl:setup-ghci-wrapper', setup_ghci_wrapper_1.setupGhciWrapper));
 42 |     }
 43 |     const commandFunction = (func) => ({ currentTarget, }) => {
 44 |         const view = editorMap.get(currentTarget.getModel());
 45 |         if (view) {
 46 |             ;
 47 |             view[func]();
 48 |         }
 49 |     };
 50 |     disposables.add(atom.commands.add('atom-text-editor.ide-haskell-repl', {
 51 |         'ide-haskell-repl:exec-command': commandFunction('execCommand'),
 52 |         'ide-haskell-repl:history-back': commandFunction('historyBack'),
 53 |         'ide-haskell-repl:history-forward': commandFunction('historyForward'),
 54 |         'ide-haskell-repl:ghci-reload': commandFunction('ghciReload'),
 55 |         'ide-haskell-repl:reload-repeat': commandFunction('ghciReloadRepeat'),
 56 |         'ide-haskell-repl:toggle-auto-reload-repeat': commandFunction('toggleAutoReloadRepeat'),
 57 |         'ide-haskell-repl:ghci-interrupt': commandFunction('interrupt'),
 58 |         'ide-haskell-repl:clear-output': commandFunction('clear'),
 59 |     }));
 60 |     const externalCommandFunction = (func) => ({ currentTarget, }) => {
 61 |         open(currentTarget.getModel(), false).then((model) => model[func]());
 62 |     };
 63 |     disposables.add(atom.commands.add('atom-text-editor:not(.ide-haskell-repl)', {
 64 |         'ide-haskell-repl:copy-selection-to-repl-input': ({ currentTarget }) => {
 65 |             const ed = currentTarget.getModel();
 66 |             const cmd = ed.getLastSelection().getText();
 67 |             open(ed).then((model) => model.copyText(cmd));
 68 |         },
 69 |         'ide-haskell-repl:run-selection-in-repl': ({ currentTarget }) => {
 70 |             const ed = currentTarget.getModel();
 71 |             const cmd = ed.getLastSelection().getText();
 72 |             open(ed, false).then(async (model) => model.runCommand(cmd));
 73 |         },
 74 |         'ide-haskell-repl:ghci-reload': externalCommandFunction('ghciReload'),
 75 |         'ide-haskell-repl:reload-repeat': externalCommandFunction('ghciReloadRepeat'),
 76 |         'ide-haskell-repl:toggle-auto-reload-repeat': externalCommandFunction('toggleAutoReloadRepeat'),
 77 |     }));
 78 |     disposables.add(atom.menu.add([
 79 |         {
 80 |             label: 'Haskell IDE',
 81 |             submenu: [
 82 |                 {
 83 |                     label: 'Open REPL',
 84 |                     command: 'ide-haskell-repl:toggle',
 85 |                 },
 86 |             ],
 87 |         },
 88 |     ]));
 89 |     setTimeout(() => {
 90 |         resolveUPIPromise();
 91 |     }, 5000);
 92 | }
 93 | exports.activate = activate;
 94 | function createReplView(state) {
 95 |     const upiPromise = initUpiPromise();
 96 |     const view = new ide_haskell_repl_view_1.IdeHaskellReplView({ upiPromise, state, watchEditorPromise });
 97 |     editorMap.set(view.editor, view);
 98 |     return view;
 99 | }
100 | exports.createReplView = createReplView;
101 | async function open(editor, activate = true) {
102 |     const grammar = editor && editor.getGrammar();
103 |     const scope = grammar && grammar.scopeName;
104 |     let uri;
105 |     if (scope && scope.endsWith('haskell')) {
106 |         uri = editor.getPath();
107 |     }
108 |     else {
109 |         uri = '';
110 |     }
111 |     return atom.workspace.open(`ide-haskell://repl/${uri}`, {
112 |         split: 'right',
113 |         searchAllPanes: true,
114 |         activatePane: activate,
115 |     });
116 | }
117 | function deactivate() {
118 |     upiPromise = undefined;
119 |     disposables.dispose();
120 | }
121 | exports.deactivate = deactivate;
122 | function consumeUPI(register) {
123 |     const consumer = new upiConsumer_1.UPIConsumer(register);
124 |     disposables.add(consumer);
125 |     resolveUPIPromise(consumer);
126 |     return consumer;
127 | }
128 | exports.consumeUPI = consumeUPI;
129 | function autocompleteProvider_3_0_0() {
130 |     return {
131 |         scopeSelector: '.source.haskell',
132 |         disableForScopeSelector: '.source.haskell .comment',
133 |         inclusionPriority: 0,
134 |         labels: ['ide-haskell-repl'],
135 |         getSuggestions: async ({ editor, prefix, }) => {
136 |             const view = editorMap.get(editor);
137 |             if (!view) {
138 |                 return [];
139 |             }
140 |             return view.getCompletions(prefix);
141 |         },
142 |     };
143 | }
144 | exports.autocompleteProvider_3_0_0 = autocompleteProvider_3_0_0;
145 | function consumeWatchEditor(watchEditor) {
146 |     resolveWatchEditorPromise(watchEditor);
147 | }
148 | exports.consumeWatchEditor = consumeWatchEditor;
149 | async function initUpiPromise() {
150 |     if (!upiPromise) {
151 |         upiPromise = new Promise((resolve) => {
152 |             resolveUPIPromise = resolve;
153 |         });
154 |     }
155 |     return upiPromise;
156 | }
157 | //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ide-haskell-repl.js","sourceRoot":"","sources":["../src/ide-haskell-repl.ts"],"names":[],"mappings":";;;AAAA,+BAMa;AACb,yEAA8E;AAE9E,+CAA2C;AAC3C,iCAAsC;AACtC,6DAAuD;AAEvD,mDAAwB;AAExB,IAAI,WAAgC,CAAA;AACpC,MAAM,SAAS,GAA4C,IAAI,OAAO,EAAE,CAAA;AACxE,IAAI,iBAA8C,CAAA;AAClD,IAAI,UAAwD,CAAA;AAC5D,IAAI,yBAAqD,CAAA;AACzD,MAAM,kBAAkB,GAAG,IAAI,OAAO,CAAe,CAAC,OAAO,EAAE,EAAE;IAC/D,yBAAyB,GAAG,OAAO,CAAA;AACrC,CAAC,CAAC,CAAA;AAEF,SAAgB,QAAQ;IACtB,WAAW,GAAG,IAAI,0BAAmB,EAAE,CAAA;IAGvC,QAAQ,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,kBAAkB,CAAC,CAAC,WAAqB,EAAE;QACjE,KAAK,OAAO;YACV,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,8BAA8B,EAAE,UAAU,CAAC,CAAA;YAC3D,MAAK;QACP,KAAK,WAAW,CAAC;QACjB,KAAK,WAAW;YACd,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,8BAA8B,EAAE,UAAU,CAAC,CAAA;YAC3D,MAAK;KACR;IAED,cAAc,EAAE,CAAA;IAEhB,WAAW,CAAC,GAAG,CACb,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC,SAAiB,EAAE,EAAE;QAC7C,MAAM,CAAC,GAAG,SAAS,CAAC,KAAK,CAAC,8BAA8B,CAAC,CAAA;QAEzD,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,SAAS,EAAE;YAC3B,OAAO,cAAc,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAA;SAClD;QACD,OAAO,SAAS,CAAA;IAClB,CAAC,CAAC,CACH,CAAA;IAED,WAAW,CAAC,GAAG,CACb,IAAI,CAAC,QAAQ,CAAC,GAAG,CACf,kBAAkB,EAClB,yBAAyB,EACzB,KAAK,EAAE,EAAE,aAAa,EAAE,EAAE,EAAE;QAC1B,oBAAa,CAAC,IAAI,CAAC,aAAa,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAA;IAC/C,CAAC,CACF,CACF,CAAA;IAGD,IAAI,OAAO,CAAC,QAAQ,KAAK,OAAO,EAAE;QAChC,WAAW,CAAC,GAAG,CACb,IAAI,CAAC,QAAQ,CAAC,GAAG,CACf,gBAAgB,EAChB,qCAAqC,EACrC,qCAAgB,CACjB,CACF,CAAA;KACF;IAED,MAAM,eAAe,GAAG,CAAC,IAAY,EAAE,EAAE,CAAC,CAAC,EACzC,aAAa,GACmB,EAAE,EAAE;QACpC,MAAM,IAAI,GAAG,SAAS,CAAC,GAAG,CAAC,aAAa,CAAC,QAAQ,EAAE,CAAC,CAAA;QACpD,IAAI,IAAI,EAAE;YACR,CAAC;YAAC,IAAI,CAAC,IAAI,CAAgB,EAAE,CAAA;SAC9B;IACH,CAAC,CAAA;IAED,WAAW,CAAC,GAAG,CACb,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,mCAAmC,EAAE;QACrD,+BAA+B,EAAE,eAAe,CAAC,aAAa,CAAC;QAC/D,+BAA+B,EAAE,eAAe,CAAC,aAAa,CAAC;QAC/D,kCAAkC,EAAE,eAAe,CAAC,gBAAgB,CAAC;QACrE,8BAA8B,EAAE,eAAe,CAAC,YAAY,CAAC;QAC7D,gCAAgC,EAAE,eAAe,CAAC,kBAAkB,CAAC;QACrE,4CAA4C,EAAE,eAAe,CAC3D,wBAAwB,CACzB;QACD,iCAAiC,EAAE,eAAe,CAAC,WAAW,CAAC;QAC/D,+BAA+B,EAAE,eAAe,CAAC,OAAO,CAAC;KAC1D,CAAC,CACH,CAAA;IAED,MAAM,uBAAuB,GAAG,CAAC,IAAY,EAAE,EAAE,CAAC,CAAC,EACjD,aAAa,GACmB,EAAE,EAAE;QAEpC,IAAI,CAAC,aAAa,CAAC,QAAQ,EAAE,EAAE,KAAK,CAAC,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAClD,KAAK,CAAC,IAAI,CAAgB,EAAE,CAC9B,CAAA;IACH,CAAC,CAAA;IAED,WAAW,CAAC,GAAG,CACb,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,yCAAyC,EAAE;QAC3D,+CAA+C,EAAE,CAAC,EAAE,aAAa,EAAE,EAAE,EAAE;YACrE,MAAM,EAAE,GAAG,aAAa,CAAC,QAAQ,EAAE,CAAA;YACnC,MAAM,GAAG,GAAG,EAAE,CAAC,gBAAgB,EAAE,CAAC,OAAO,EAAE,CAAA;YAE3C,IAAI,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAA;QAC/C,CAAC;QACD,wCAAwC,EAAE,CAAC,EAAE,aAAa,EAAE,EAAE,EAAE;YAC9D,MAAM,EAAE,GAAG,aAAa,CAAC,QAAQ,EAAE,CAAA;YACnC,MAAM,GAAG,GAAG,EAAE,CAAC,gBAAgB,EAAE,CAAC,OAAO,EAAE,CAAA;YAE3C,IAAI,CAAC,EAAE,EAAE,KAAK,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAA;QAC9D,CAAC;QACD,8BAA8B,EAAE,uBAAuB,CAAC,YAAY,CAAC;QACrE,gCAAgC,EAAE,uBAAuB,CACvD,kBAAkB,CACnB;QACD,4CAA4C,EAAE,uBAAuB,CACnE,wBAAwB,CACzB;KACF,CAAC,CACH,CAAA;IAED,WAAW,CAAC,GAAG,CACb,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC;QACZ;YACE,KAAK,EAAE,aAAa;YACpB,OAAO,EAAE;gBACP;oBACE,KAAK,EAAE,WAAW;oBAClB,OAAO,EAAE,yBAAyB;iBACnC;aACF;SACF;KACF,CAAC,CACH,CAAA;IAED,UAAU,CAAC,GAAG,EAAE;QACd,iBAAiB,EAAE,CAAA;IACrB,CAAC,EAAE,IAAI,CAAC,CAAA;AACV,CAAC;AA1HD,4BA0HC;AAED,SAAgB,cAAc,CAAC,KAAiB;IAC9C,MAAM,UAAU,GAAG,cAAc,EAAE,CAAA;IACnC,MAAM,IAAI,GAAG,IAAI,0CAAkB,CAAC,EAAE,UAAU,EAAE,KAAK,EAAE,kBAAkB,EAAE,CAAC,CAAA;IAC9E,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,CAAA;IAChC,OAAO,IAAI,CAAA;AACb,CAAC;AALD,wCAKC;AAED,KAAK,UAAU,IAAI,CACjB,MAAkB,EAClB,QAAQ,GAAG,IAAI;IAEf,MAAM,OAAO,GAAG,MAAM,IAAI,MAAM,CAAC,UAAU,EAAE,CAAA;IAC7C,MAAM,KAAK,GAAG,OAAO,IAAI,OAAO,CAAC,SAAS,CAAA;IAC1C,IAAI,GAAG,CAAA;IACP,IAAI,KAAK,IAAI,KAAK,CAAC,QAAQ,CAAC,SAAS,CAAC,EAAE;QACtC,GAAG,GAAG,MAAM,CAAC,OAAO,EAAE,CAAA;KACvB;SAAM;QACL,GAAG,GAAG,EAAE,CAAA;KACT;IACD,OAAO,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,sBAAsB,GAAG,EAAE,EAAE;QACtD,KAAK,EAAE,OAAO;QACd,cAAc,EAAE,IAAI;QACpB,YAAY,EAAE,QAAQ;KACvB,CAAgC,CAAA;AACnC,CAAC;AAED,SAAgB,UAAU;IACxB,UAAU,GAAG,SAAS,CAAA;IACtB,WAAW,CAAC,OAAO,EAAE,CAAA;AACvB,CAAC;AAHD,gCAGC;AAED,SAAgB,UAAU,CAAC,QAA8B;IACvD,MAAM,QAAQ,GAAG,IAAI,yBAAW,CAAC,QAAQ,CAAC,CAAA;IAC1C,WAAW,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAA;IACzB,iBAAiB,CAAC,QAAQ,CAAC,CAAA;IAC3B,OAAO,QAAQ,CAAA;AACjB,CAAC;AALD,gCAKC;AAED,SAAgB,0BAA0B;IACxC,OAAO;QACL,aAAa,EAAE,iBAAiB;QAChC,uBAAuB,EAAE,0BAA0B;QAEnD,iBAAiB,EAAE,CAAC;QACpB,MAAM,EAAE,CAAC,kBAAkB,CAAC;QAC5B,cAAc,EAAE,KAAK,EAAE,EACrB,MAAM,EACN,MAAM,GAIP,EAAE,EAAE;YACH,MAAM,IAAI,GAAG,SAAS,CAAC,GAAG,CAAC,MAAM,CAAC,CAAA;YAClC,IAAI,CAAC,IAAI,EAAE;gBACT,OAAO,EAAE,CAAA;aACV;YACD,OAAO,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,CAAA;QACpC,CAAC;KACF,CAAA;AACH,CAAC;AArBD,gEAqBC;AAED,SAAgB,kBAAkB,CAAC,WAAyB;IAC1D,yBAAyB,CAAC,WAAW,CAAC,CAAA;AACxC,CAAC;AAFD,gDAEC;AAED,KAAK,UAAU,cAAc;IAC3B,IAAI,CAAC,UAAU,EAAE;QACf,UAAU,GAAG,IAAI,OAAO,CAA0B,CAAC,OAAO,EAAE,EAAE;YAC5D,iBAAiB,GAAG,OAAO,CAAA;QAC7B,CAAC,CAAC,CAAA;KACH;IACD,OAAO,UAAU,CAAA;AACnB,CAAC","sourcesContent":["import {\n  CompositeDisposable,\n  TWatchEditor,\n  CommandEvent,\n  TextEditor,\n  TextEditorElement,\n} from 'atom'\nimport { IdeHaskellReplView, IViewState } from './views/ide-haskell-repl-view'\nimport * as UPI from 'atom-haskell-upi'\nimport { UPIConsumer } from './upiConsumer'\nimport { handlePromise } from './util'\nimport { setupGhciWrapper } from './setup-ghci-wrapper'\n\nexport * from './config'\n\nlet disposables: CompositeDisposable\nconst editorMap: WeakMap<TextEditor, IdeHaskellReplView> = new WeakMap()\nlet resolveUPIPromise: (upi?: UPIConsumer) => void\nlet upiPromise: Promise<UPIConsumer | undefined> | undefined\nlet resolveWatchEditorPromise: (we: TWatchEditor) => void\nconst watchEditorPromise = new Promise<TWatchEditor>((resolve) => {\n  resolveWatchEditorPromise = resolve\n})\n\nexport function activate() {\n  disposables = new CompositeDisposable()\n\n  // backwards compatibility\n  switch (atom.config.get('ide-haskell-repl').defaultRepl as string) {\n    case 'cabal':\n      atom.config.set('ide-haskell-repl.defaultRepl', 'cabal-v1')\n      break\n    case 'cabal-nix':\n    case 'cabal-new':\n      atom.config.set('ide-haskell-repl.defaultRepl', 'cabal-v2')\n      break\n  }\n  // tslint:disable-next-line:no-floating-promises\n  initUpiPromise()\n\n  disposables.add(\n    atom.workspace.addOpener((uriToOpen: string) => {\n      const m = uriToOpen.match(/^ide-haskell:\\/\\/repl\\/(.*)$/)\n      // tslint:disable-next-line:strict-type-predicates\n      if (m && m[1] !== undefined) {\n        return createReplView({ uri: m[1], focus: true })\n      }\n      return undefined\n    }),\n  )\n\n  disposables.add(\n    atom.commands.add(\n      'atom-text-editor',\n      'ide-haskell-repl:toggle',\n      async ({ currentTarget }) => {\n        handlePromise(open(currentTarget.getModel()))\n      },\n    ),\n  )\n\n  // tslint:disable-next-line: totality-check\n  if (process.platform === 'win32') {\n    disposables.add(\n      atom.commands.add(\n        'atom-workspace',\n        'ide-haskell-repl:setup-ghci-wrapper',\n        setupGhciWrapper,\n      ),\n    )\n  }\n\n  const commandFunction = (func: string) => ({\n    currentTarget,\n  }: CommandEvent<TextEditorElement>) => {\n    const view = editorMap.get(currentTarget.getModel())\n    if (view) {\n      ;(view[func] as () => void)()\n    }\n  }\n\n  disposables.add(\n    atom.commands.add('atom-text-editor.ide-haskell-repl', {\n      'ide-haskell-repl:exec-command': commandFunction('execCommand'),\n      'ide-haskell-repl:history-back': commandFunction('historyBack'),\n      'ide-haskell-repl:history-forward': commandFunction('historyForward'),\n      'ide-haskell-repl:ghci-reload': commandFunction('ghciReload'),\n      'ide-haskell-repl:reload-repeat': commandFunction('ghciReloadRepeat'),\n      'ide-haskell-repl:toggle-auto-reload-repeat': commandFunction(\n        'toggleAutoReloadRepeat',\n      ),\n      'ide-haskell-repl:ghci-interrupt': commandFunction('interrupt'),\n      'ide-haskell-repl:clear-output': commandFunction('clear'),\n    }),\n  )\n\n  const externalCommandFunction = (func: string) => ({\n    currentTarget,\n  }: CommandEvent<TextEditorElement>) => {\n    // tslint:disable-next-line:no-floating-promises\n    open(currentTarget.getModel(), false).then((model) =>\n      (model[func] as () => void)(),\n    )\n  }\n\n  disposables.add(\n    atom.commands.add('atom-text-editor:not(.ide-haskell-repl)', {\n      'ide-haskell-repl:copy-selection-to-repl-input': ({ currentTarget }) => {\n        const ed = currentTarget.getModel()\n        const cmd = ed.getLastSelection().getText()\n        // tslint:disable-next-line:no-floating-promises\n        open(ed).then((model) => model.copyText(cmd))\n      },\n      'ide-haskell-repl:run-selection-in-repl': ({ currentTarget }) => {\n        const ed = currentTarget.getModel()\n        const cmd = ed.getLastSelection().getText()\n        // tslint:disable-next-line:no-floating-promises\n        open(ed, false).then(async (model) => model.runCommand(cmd))\n      },\n      'ide-haskell-repl:ghci-reload': externalCommandFunction('ghciReload'),\n      'ide-haskell-repl:reload-repeat': externalCommandFunction(\n        'ghciReloadRepeat',\n      ),\n      'ide-haskell-repl:toggle-auto-reload-repeat': externalCommandFunction(\n        'toggleAutoReloadRepeat',\n      ),\n    }),\n  )\n\n  disposables.add(\n    atom.menu.add([\n      {\n        label: 'Haskell IDE',\n        submenu: [\n          {\n            label: 'Open REPL',\n            command: 'ide-haskell-repl:toggle',\n          },\n        ],\n      },\n    ]),\n  )\n\n  setTimeout(() => {\n    resolveUPIPromise()\n  }, 5000)\n}\n\nexport function createReplView(state: IViewState) {\n  const upiPromise = initUpiPromise()\n  const view = new IdeHaskellReplView({ upiPromise, state, watchEditorPromise })\n  editorMap.set(view.editor, view)\n  return view\n}\n\nasync function open(\n  editor: TextEditor,\n  activate = true,\n): Promise<IdeHaskellReplView> {\n  const grammar = editor && editor.getGrammar()\n  const scope = grammar && grammar.scopeName\n  let uri\n  if (scope && scope.endsWith('haskell')) {\n    uri = editor.getPath()\n  } else {\n    uri = ''\n  }\n  return atom.workspace.open(`ide-haskell://repl/${uri}`, {\n    split: 'right',\n    searchAllPanes: true,\n    activatePane: activate,\n  }) as Promise<IdeHaskellReplView>\n}\n\nexport function deactivate() {\n  upiPromise = undefined\n  disposables.dispose()\n}\n\nexport function consumeUPI(register: UPI.IUPIRegistration) {\n  const consumer = new UPIConsumer(register)\n  disposables.add(consumer)\n  resolveUPIPromise(consumer)\n  return consumer\n}\n\nexport function autocompleteProvider_3_0_0() {\n  return {\n    scopeSelector: '.source.haskell',\n    disableForScopeSelector: '.source.haskell .comment',\n    // getTextEditorSelector: () => 'atom-text-editor.ide-haskell-repl',\n    inclusionPriority: 0,\n    labels: ['ide-haskell-repl'],\n    getSuggestions: async ({\n      editor,\n      prefix,\n    }: {\n      editor: TextEditor\n      prefix: string\n    }) => {\n      const view = editorMap.get(editor)\n      if (!view) {\n        return []\n      }\n      return view.getCompletions(prefix)\n    },\n  }\n}\n\nexport function consumeWatchEditor(watchEditor: TWatchEditor) {\n  resolveWatchEditorPromise(watchEditor)\n}\n\nasync function initUpiPromise() {\n  if (!upiPromise) {\n    upiPromise = new Promise<UPIConsumer | undefined>((resolve) => {\n      resolveUPIPromise = resolve\n    })\n  }\n  return upiPromise\n}\n"]}


--------------------------------------------------------------------------------
/lib/upiConsumer.js:
--------------------------------------------------------------------------------
  1 | "use strict";
  2 | Object.defineProperty(exports, "__esModule", { value: true });
  3 | const atom_1 = require("atom");
  4 | const ide_haskell_repl_base_1 = require("./ide-haskell-repl-base");
  5 | const ide_haskell_repl_bg_1 = require("./ide-haskell-repl-bg");
  6 | class UPIConsumer {
  7 |     constructor(register) {
  8 |         this.messages = [];
  9 |         this.errors = new Map();
 10 |         this.disposables = new atom_1.CompositeDisposable();
 11 |         this.maxMessageTime = 10000;
 12 |         this.bgEditorMap = new Map();
 13 |         this.disposables.add((this.upiRepl = register({
 14 |             name: 'ide-haskell-repl',
 15 |             messageTypes: {
 16 |                 repl: {
 17 |                     uriFilter: false,
 18 |                     autoScroll: true,
 19 |                 },
 20 |             },
 21 |             tooltip: this.shouldShowTooltip.bind(this),
 22 |             events: {
 23 |                 onDidSaveBuffer: this.didSaveBuffer.bind(this),
 24 |             },
 25 |         })), (this.upiErrors = register({
 26 |             name: 'ide-haskell-repl::errors',
 27 |         })));
 28 |     }
 29 |     dispose() {
 30 |         this.disposables.dispose();
 31 |     }
 32 |     async getBuilder() {
 33 |         const builder = await this.upiRepl.getOthersConfigParam('ide-haskell-cabal', 'builder');
 34 |         switch (builder && builder.name) {
 35 |             case 'cabal':
 36 |                 builder.name = 'cabal-v1';
 37 |                 break;
 38 |             case 'cabal-nix':
 39 |                 builder.name = 'cabal-v2';
 40 |                 break;
 41 |         }
 42 |         return builder;
 43 |     }
 44 |     setErrors(source, errors) {
 45 |         this.errors.set(source, this.convert(errors));
 46 |         this.sendAllErrors();
 47 |     }
 48 |     setMessages(messages) {
 49 |         const all = this.convert(messages);
 50 |         this.messages = this.messages.filter(({ _time }) => Date.now() - _time < this.maxMessageTime);
 51 |         this.messages.push(...all.filter(({ severity }) => severity === 'repl'));
 52 |         this.upiRepl.setMessages(this.messages);
 53 |     }
 54 |     convert(xs) {
 55 |         const _time = Date.now();
 56 |         return xs.map((x) => (Object.assign(Object.assign({}, x), { _time })));
 57 |     }
 58 |     sendAllErrors() {
 59 |         let errors = [];
 60 |         for (const [source, errorArr] of this.errors.entries()) {
 61 |             if (!atom.config.get('ide-haskell-repl.checkOnSave') &&
 62 |                 source.startsWith('bg:')) {
 63 |                 continue;
 64 |             }
 65 |             errors = errors.filter((x) => !errorArr.some((y) => x._time <= y._time &&
 66 |                 x.context === y.context &&
 67 |                 compareMessage(x.message, y.message) &&
 68 |                 comparePosition(x.position, y.position) &&
 69 |                 x.severity === y.severity));
 70 |             errors.push(...errorArr);
 71 |         }
 72 |         this.upiErrors.setMessages(errors);
 73 |     }
 74 |     async shouldShowTooltip(editor, crange, _type) {
 75 |         if (!atom.config.get('ide-haskell-repl.showTypes')) {
 76 |             return undefined;
 77 |         }
 78 |         const path = editor.getPath();
 79 |         if (!path)
 80 |             return undefined;
 81 |         const buffer = editor.getBuffer();
 82 |         const { bg } = await this.getBgRepl(buffer);
 83 |         if (!bg)
 84 |             return undefined;
 85 |         return bg.showTypeAt(path, crange);
 86 |     }
 87 |     async didSaveBuffer(buffer) {
 88 |         if (!atom.config.get('ide-haskell-repl.checkOnSave') &&
 89 |             !atom.config.get('ide-haskell-repl.showTypes')) {
 90 |             return;
 91 |         }
 92 |         const { bg, isNew } = await this.getBgRepl(buffer);
 93 |         if (bg) {
 94 |             if (isNew)
 95 |                 await bg.readyPromise;
 96 |             else
 97 |                 await bg.ghciReload();
 98 |         }
 99 |     }
100 |     async getBgRepl(buffer) {
101 |         const path = buffer.getPath();
102 |         if (!path)
103 |             return { bg: undefined, isNew: false };
104 |         const { cwd, cabal, comp } = await ide_haskell_repl_base_1.IdeHaskellReplBase.componentFromURI(path);
105 |         const hash = `${cwd.getPath()}::${cabal && cabal.name}::${comp && comp[0]}`;
106 |         let bgrec = this.bgEditorMap.get(hash);
107 |         let isNew = false;
108 |         if (!bgrec) {
109 |             bgrec = this.createNewBgRepl(hash, path);
110 |             isNew = true;
111 |         }
112 |         subscribeToBuffer(bgrec, buffer);
113 |         return { bg: bgrec.bg, isNew };
114 |     }
115 |     createNewBgRepl(hash, path) {
116 |         const bg = new ide_haskell_repl_bg_1.IdeHaskellReplBg(this, { uri: path });
117 |         const bgrec = {
118 |             bg,
119 |             references: 0,
120 |             buffers: new WeakSet(),
121 |             disposables: new atom_1.CompositeDisposable(),
122 |             dispose: () => {
123 |                 this.disposables.delete(bgrec);
124 |                 this.bgEditorMap.delete(hash);
125 |                 bgrec.bg.destroy();
126 |                 bgrec.disposables.dispose();
127 |             },
128 |         };
129 |         this.disposables.add(bgrec);
130 |         this.bgEditorMap.set(hash, bgrec);
131 |         bgrec.disposables.add(bg.onDidDestroy(() => {
132 |             bgrec.dispose();
133 |         }));
134 |         return bgrec;
135 |     }
136 | }
137 | exports.UPIConsumer = UPIConsumer;
138 | function subscribeToBuffer(rec, buffer) {
139 |     if (rec.buffers.has(buffer))
140 |         return;
141 |     rec.references++;
142 |     rec.buffers.add(buffer);
143 |     rec.disposables.add(buffer.onDidDestroy(() => {
144 |         rec.buffers.delete(buffer);
145 |         rec.references--;
146 |         if (rec.references === 0) {
147 |             rec.dispose();
148 |         }
149 |     }));
150 | }
151 | function comparePosition(x, y) {
152 |     if (x && y) {
153 |         return atom_1.Point.fromObject(x).isEqual(y);
154 |     }
155 |     else {
156 |         return x === y;
157 |     }
158 | }
159 | function compareMessage(x, y) {
160 |     if (typeof x === 'string' && typeof y === 'string') {
161 |         return x === y;
162 |     }
163 |     else if (isTextMessage(x) && isTextMessage(y)) {
164 |         return x.text === y.text;
165 |     }
166 |     else if (isHTMLMessage(x) && isHTMLMessage(y)) {
167 |         return x.html === y.html;
168 |     }
169 |     return false;
170 | }
171 | function isTextMessage(x) {
172 |     return x.text !== undefined;
173 | }
174 | function isHTMLMessage(x) {
175 |     return x.text !== undefined;
176 | }
177 | //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"upiConsumer.js","sourceRoot":"","sources":["../src/upiConsumer.ts"],"names":[],"mappings":";;AAOA,+BAOa;AACb,mEAA4D;AAC5D,+DAAwD;AAcxD,MAAa,WAAW;IAStB,YAAY,QAA0B;QAN9B,aAAQ,GAAiB,EAAE,CAAA;QAC3B,WAAM,GAA8B,IAAI,GAAG,EAAE,CAAA;QAC7C,gBAAW,GAAG,IAAI,0BAAmB,EAAE,CAAA;QACvC,mBAAc,GAAG,KAAK,CAAA;QACtB,gBAAW,GAAG,IAAI,GAAG,EAAiB,CAAA;QAG5C,IAAI,CAAC,WAAW,CAAC,GAAG,CAClB,CAAC,IAAI,CAAC,OAAO,GAAG,QAAQ,CAAC;YACvB,IAAI,EAAE,kBAAkB;YACxB,YAAY,EAAE;gBACZ,IAAI,EAAE;oBACJ,SAAS,EAAE,KAAK;oBAChB,UAAU,EAAE,IAAI;iBACjB;aACF;YACD,OAAO,EAAE,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,IAAI,CAAC;YAC1C,MAAM,EAAE;gBACN,eAAe,EAAE,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC;aAC/C;SACF,CAAC,CAAC,EACH,CAAC,IAAI,CAAC,SAAS,GAAG,QAAQ,CAAC;YACzB,IAAI,EAAE,0BAA0B;SACjC,CAAC,CAAC,CACJ,CAAA;IACH,CAAC;IAEM,OAAO;QACZ,IAAI,CAAC,WAAW,CAAC,OAAO,EAAE,CAAA;IAC5B,CAAC;IAEM,KAAK,CAAC,UAAU;QAMrB,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,oBAAoB,CAEpD,mBAAmB,EAAE,SAAS,CAAC,CAAA;QAElC,QAAQ,OAAO,IAAK,OAAO,CAAC,IAAe,EAAE;YAC3C,KAAK,OAAO;gBAEV,OAAQ,CAAC,IAAI,GAAG,UAAmB,CAAA;gBACnC,MAAK;YACP,KAAK,WAAW;gBAEd,OAAQ,CAAC,IAAI,GAAG,UAAmB,CAAA;gBACnC,MAAK;SACR;QACD,OAAO,OAAO,CAAA;IAChB,CAAC;IAEM,SAAS,CAAC,MAAc,EAAE,MAAqB;QACpD,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAA;QAC7C,IAAI,CAAC,aAAa,EAAE,CAAA;IACtB,CAAC;IAEM,WAAW,CAAC,QAAuB;QACxC,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAA;QAClC,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC,MAAM,CAClC,CAAC,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,KAAK,GAAG,IAAI,CAAC,cAAc,CACxD,CAAA;QACD,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,CAAC,EAAE,QAAQ,EAAE,EAAE,EAAE,CAAC,QAAQ,KAAK,MAAM,CAAC,CAAC,CAAA;QACxE,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAA;IACzC,CAAC;IAEO,OAAO,CAAC,EAAiB;QAC/B,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,EAAE,CAAA;QACxB,OAAO,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,iCAAM,CAAC,KAAE,KAAK,IAAG,CAAC,CAAA;IACzC,CAAC;IAEO,aAAa;QACnB,IAAI,MAAM,GAAiB,EAAE,CAAA;QAC7B,KAAK,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,IAAI,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,EAAE;YACtD,IACE,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,8BAA8B,CAAC;gBAChD,MAAM,CAAC,UAAU,CAAC,KAAK,CAAC,EACxB;gBACA,SAAQ;aACT;YACD,MAAM,GAAG,MAAM,CAAC,MAAM,CACpB,CAAC,CAAC,EAAE,EAAE,CACJ,CAAC,QAAQ,CAAC,IAAI,CACZ,CAAC,CAAC,EAAE,EAAE,CACJ,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC,KAAK;gBAClB,CAAC,CAAC,OAAO,KAAK,CAAC,CAAC,OAAO;gBACvB,cAAc,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC,OAAO,CAAC;gBACpC,eAAe,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC,CAAC,QAAQ,CAAC;gBACvC,CAAC,CAAC,QAAQ,KAAK,CAAC,CAAC,QAAQ,CAC5B,CACJ,CAAA;YACD,MAAM,CAAC,IAAI,CAAC,GAAG,QAAQ,CAAC,CAAA;SACzB;QACD,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,MAAM,CAAC,CAAA;IACpC,CAAC;IAEO,KAAK,CAAC,iBAAiB,CAC7B,MAAkB,EAClB,MAAa,EACb,KAAa;QAEb,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,4BAA4B,CAAC,EAAE;YAClD,OAAO,SAAS,CAAA;SACjB;QACD,MAAM,IAAI,GAAG,MAAM,CAAC,OAAO,EAAE,CAAA;QAC7B,IAAI,CAAC,IAAI;YAAE,OAAO,SAAS,CAAA;QAC3B,MAAM,MAAM,GAAG,MAAM,CAAC,SAAS,EAAE,CAAA;QACjC,MAAM,EAAE,EAAE,EAAE,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAA;QAC3C,IAAI,CAAC,EAAE;YAAE,OAAO,SAAS,CAAA;QACzB,OAAO,EAAE,CAAC,UAAU,CAAC,IAAI,EAAE,MAAM,CAAC,CAAA;IACpC,CAAC;IAEO,KAAK,CAAC,aAAa,CAAC,MAAkB;QAC5C,IACE,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,8BAA8B,CAAC;YAChD,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,4BAA4B,CAAC,EAC9C;YACA,OAAM;SACP;QACD,MAAM,EAAE,EAAE,EAAE,KAAK,EAAE,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAA;QAClD,IAAI,EAAE,EAAE;YAEN,IAAI,KAAK;gBAAE,MAAM,EAAE,CAAC,YAAY,CAAA;;gBAC3B,MAAM,EAAE,CAAC,UAAU,EAAE,CAAA;SAC3B;IACH,CAAC;IAEO,KAAK,CAAC,SAAS,CAAC,MAAkB;QACxC,MAAM,IAAI,GAAG,MAAM,CAAC,OAAO,EAAE,CAAA;QAC7B,IAAI,CAAC,IAAI;YAAE,OAAO,EAAE,EAAE,EAAE,SAAS,EAAE,KAAK,EAAE,KAAK,EAAE,CAAA;QACjD,MAAM,EAAE,GAAG,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,MAAM,0CAAkB,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAA;QAC5E,MAAM,IAAI,GAAG,GAAG,GAAG,CAAC,OAAO,EAAE,KAAK,KAAK,IAAI,KAAK,CAAC,IAAI,KAAK,IAAI,IAAI,IAAI,CAAC,CAAC,CAAC,EAAE,CAAA;QAC3E,IAAI,KAAK,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,IAAI,CAAC,CAAA;QACtC,IAAI,KAAK,GAAG,KAAK,CAAA;QACjB,IAAI,CAAC,KAAK,EAAE;YACV,KAAK,GAAG,IAAI,CAAC,eAAe,CAAC,IAAI,EAAE,IAAI,CAAC,CAAA;YACxC,KAAK,GAAG,IAAI,CAAA;SACb;QACD,iBAAiB,CAAC,KAAK,EAAE,MAAM,CAAC,CAAA;QAChC,OAAO,EAAE,EAAE,EAAE,KAAK,CAAC,EAAE,EAAE,KAAK,EAAE,CAAA;IAChC,CAAC;IAEO,eAAe,CAAC,IAAY,EAAE,IAAY;QAChD,MAAM,EAAE,GAAG,IAAI,sCAAgB,CAAC,IAAI,EAAE,EAAE,GAAG,EAAE,IAAI,EAAE,CAAC,CAAA;QACpD,MAAM,KAAK,GAAU;YACnB,EAAE;YACF,UAAU,EAAE,CAAC;YACb,OAAO,EAAE,IAAI,OAAO,EAAE;YACtB,WAAW,EAAE,IAAI,0BAAmB,EAAE;YACtC,OAAO,EAAE,GAAG,EAAE;gBACZ,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,KAAK,CAAC,CAAA;gBAC9B,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;gBAE7B,KAAK,CAAC,EAAE,CAAC,OAAO,EAAE,CAAA;gBAClB,KAAK,CAAC,WAAW,CAAC,OAAO,EAAE,CAAA;YAC7B,CAAC;SACF,CAAA;QACD,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,KAAK,CAAC,CAAA;QAC3B,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,IAAI,EAAE,KAAK,CAAC,CAAA;QACjC,KAAK,CAAC,WAAW,CAAC,GAAG,CACnB,EAAE,CAAC,YAAY,CAAC,GAAG,EAAE;YACnB,KAAK,CAAC,OAAO,EAAE,CAAA;QACjB,CAAC,CAAC,CACH,CAAA;QACD,OAAO,KAAK,CAAA;IACd,CAAC;CACF;AA3KD,kCA2KC;AAED,SAAS,iBAAiB,CAAC,GAAU,EAAE,MAAkB;IACvD,IAAI,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC;QAAE,OAAM;IACnC,GAAG,CAAC,UAAU,EAAE,CAAA;IAChB,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAA;IACvB,GAAG,CAAC,WAAW,CAAC,GAAG,CACjB,MAAM,CAAC,YAAY,CAAC,GAAG,EAAE;QACvB,GAAG,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,CAAA;QAC1B,GAAG,CAAC,UAAU,EAAE,CAAA;QAChB,IAAI,GAAG,CAAC,UAAU,KAAK,CAAC,EAAE;YACxB,GAAG,CAAC,OAAO,EAAE,CAAA;SACd;IACH,CAAC,CAAC,CACH,CAAA;AACH,CAAC;AAED,SAAS,eAAe,CAAC,CAAmB,EAAE,CAAmB;IAC/D,IAAI,CAAC,IAAI,CAAC,EAAE;QACV,OAAO,YAAK,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAA;KACtC;SAAM;QACL,OAAO,CAAC,KAAK,CAAC,CAAA;KACf;AACH,CAAC;AAED,SAAS,cAAc,CACrB,CAAwB,EACxB,CAAwB;IAExB,IAAI,OAAO,CAAC,KAAK,QAAQ,IAAI,OAAO,CAAC,KAAK,QAAQ,EAAE;QAClD,OAAO,CAAC,KAAK,CAAC,CAAA;KACf;SAAM,IAAI,aAAa,CAAC,CAAC,CAAC,IAAI,aAAa,CAAC,CAAC,CAAC,EAAE;QAC/C,OAAO,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,IAAI,CAAA;KACzB;SAAM,IAAI,aAAa,CAAC,CAAC,CAAC,IAAI,aAAa,CAAC,CAAC,CAAC,EAAE;QAC/C,OAAO,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,IAAI,CAAA;KACzB;IACD,OAAO,KAAK,CAAA;AACd,CAAC;AAED,SAAS,aAAa,CAAC,CAAwB;IAC7C,OAAQ,CAAS,CAAC,IAAI,KAAK,SAAS,CAAA;AACtC,CAAC;AAED,SAAS,aAAa,CAAC,CAAwB;IAC7C,OAAQ,CAAS,CAAC,IAAI,KAAK,SAAS,CAAA;AACtC,CAAC","sourcesContent":["import {\n  IUPIInstance,\n  IResultItem,\n  IUPIRegistration,\n  IMessageText,\n  IMessageHTML,\n} from 'atom-haskell-upi'\nimport {\n  CompositeDisposable,\n  TextEditor,\n  Range,\n  TextBuffer,\n  Point,\n  PointCompatible,\n} from 'atom'\nimport { IdeHaskellReplBase } from './ide-haskell-repl-base'\nimport { IdeHaskellReplBg } from './ide-haskell-repl-bg'\n\nexport interface IErrorItem extends IResultItem {\n  _time: number\n}\n\nexport interface BgRec {\n  references: number\n  bg: IdeHaskellReplBg\n  buffers: WeakSet<TextBuffer>\n  disposables: CompositeDisposable\n  dispose(): void\n}\n\nexport class UPIConsumer {\n  private upiRepl: IUPIInstance\n  private upiErrors: IUPIInstance\n  private messages: IErrorItem[] = []\n  private errors: Map<string, IErrorItem[]> = new Map()\n  private disposables = new CompositeDisposable()\n  private maxMessageTime = 10000\n  private bgEditorMap = new Map<string, BgRec>()\n\n  constructor(register: IUPIRegistration) {\n    this.disposables.add(\n      (this.upiRepl = register({\n        name: 'ide-haskell-repl',\n        messageTypes: {\n          repl: {\n            uriFilter: false,\n            autoScroll: true,\n          },\n        },\n        tooltip: this.shouldShowTooltip.bind(this),\n        events: {\n          onDidSaveBuffer: this.didSaveBuffer.bind(this),\n        },\n      })),\n      (this.upiErrors = register({\n        name: 'ide-haskell-repl::errors',\n      })),\n    )\n  }\n\n  public dispose() {\n    this.disposables.dispose()\n  }\n\n  public async getBuilder(): Promise<\n    | {\n        name: 'cabal-v1' | 'stack' | 'cabal-v2' | 'none'\n      }\n    | undefined\n  > {\n    const builder = await this.upiRepl.getOthersConfigParam<{\n      name: 'cabal-v1' | 'stack' | 'cabal-v2' | 'none'\n    }>('ide-haskell-cabal', 'builder')\n    // backwards compatibility\n    switch (builder && (builder.name as string)) {\n      case 'cabal':\n        // tslint:disable-next-line: no-non-null-assertion\n        builder!.name = 'cabal-v1' as const\n        break\n      case 'cabal-nix':\n        // tslint:disable-next-line: no-non-null-assertion\n        builder!.name = 'cabal-v2' as const\n        break\n    }\n    return builder\n  }\n\n  public setErrors(source: string, errors: IResultItem[]) {\n    this.errors.set(source, this.convert(errors))\n    this.sendAllErrors()\n  }\n\n  public setMessages(messages: IResultItem[]) {\n    const all = this.convert(messages)\n    this.messages = this.messages.filter(\n      ({ _time }) => Date.now() - _time < this.maxMessageTime,\n    )\n    this.messages.push(...all.filter(({ severity }) => severity === 'repl'))\n    this.upiRepl.setMessages(this.messages)\n  }\n\n  private convert(xs: IResultItem[]): IErrorItem[] {\n    const _time = Date.now()\n    return xs.map((x) => ({ ...x, _time }))\n  }\n\n  private sendAllErrors() {\n    let errors: IErrorItem[] = []\n    for (const [source, errorArr] of this.errors.entries()) {\n      if (\n        !atom.config.get('ide-haskell-repl.checkOnSave') &&\n        source.startsWith('bg:')\n      ) {\n        continue\n      }\n      errors = errors.filter(\n        (x) =>\n          !errorArr.some(\n            (y) =>\n              x._time <= y._time &&\n              x.context === y.context &&\n              compareMessage(x.message, y.message) &&\n              comparePosition(x.position, y.position) &&\n              x.severity === y.severity,\n          ),\n      )\n      errors.push(...errorArr)\n    }\n    this.upiErrors.setMessages(errors)\n  }\n\n  private async shouldShowTooltip(\n    editor: TextEditor,\n    crange: Range,\n    _type: string,\n  ) {\n    if (!atom.config.get('ide-haskell-repl.showTypes')) {\n      return undefined\n    }\n    const path = editor.getPath()\n    if (!path) return undefined\n    const buffer = editor.getBuffer()\n    const { bg } = await this.getBgRepl(buffer)\n    if (!bg) return undefined\n    return bg.showTypeAt(path, crange)\n  }\n\n  private async didSaveBuffer(buffer: TextBuffer) {\n    if (\n      !atom.config.get('ide-haskell-repl.checkOnSave') &&\n      !atom.config.get('ide-haskell-repl.showTypes')\n    ) {\n      return\n    }\n    const { bg, isNew } = await this.getBgRepl(buffer)\n    if (bg) {\n      // no need to reload newly created instance since it reloads on start\n      if (isNew) await bg.readyPromise\n      else await bg.ghciReload()\n    }\n  }\n\n  private async getBgRepl(buffer: TextBuffer) {\n    const path = buffer.getPath()\n    if (!path) return { bg: undefined, isNew: false }\n    const { cwd, cabal, comp } = await IdeHaskellReplBase.componentFromURI(path)\n    const hash = `${cwd.getPath()}::${cabal && cabal.name}::${comp && comp[0]}`\n    let bgrec = this.bgEditorMap.get(hash)\n    let isNew = false\n    if (!bgrec) {\n      bgrec = this.createNewBgRepl(hash, path)\n      isNew = true\n    }\n    subscribeToBuffer(bgrec, buffer)\n    return { bg: bgrec.bg, isNew }\n  }\n\n  private createNewBgRepl(hash: string, path: string) {\n    const bg = new IdeHaskellReplBg(this, { uri: path })\n    const bgrec: BgRec = {\n      bg,\n      references: 0,\n      buffers: new WeakSet(),\n      disposables: new CompositeDisposable(),\n      dispose: () => {\n        this.disposables.delete(bgrec)\n        this.bgEditorMap.delete(hash)\n        // tslint:disable-next-line:no-floating-promises\n        bgrec.bg.destroy()\n        bgrec.disposables.dispose()\n      },\n    }\n    this.disposables.add(bgrec)\n    this.bgEditorMap.set(hash, bgrec)\n    bgrec.disposables.add(\n      bg.onDidDestroy(() => {\n        bgrec.dispose()\n      }),\n    )\n    return bgrec\n  }\n}\n\nfunction subscribeToBuffer(rec: BgRec, buffer: TextBuffer) {\n  if (rec.buffers.has(buffer)) return\n  rec.references++\n  rec.buffers.add(buffer)\n  rec.disposables.add(\n    buffer.onDidDestroy(() => {\n      rec.buffers.delete(buffer)\n      rec.references--\n      if (rec.references === 0) {\n        rec.dispose()\n      }\n    }),\n  )\n}\n\nfunction comparePosition(x?: PointCompatible, y?: PointCompatible): boolean {\n  if (x && y) {\n    return Point.fromObject(x).isEqual(y)\n  } else {\n    return x === y\n  }\n}\n\nfunction compareMessage(\n  x: IErrorItem['message'],\n  y: IErrorItem['message'],\n): boolean {\n  if (typeof x === 'string' && typeof y === 'string') {\n    return x === y\n  } else if (isTextMessage(x) && isTextMessage(y)) {\n    return x.text === y.text\n  } else if (isHTMLMessage(x) && isHTMLMessage(y)) {\n    return x.html === y.html\n  }\n  return false\n}\n\nfunction isTextMessage(x: IErrorItem['message']): x is IMessageText {\n  return (x as any).text !== undefined\n}\n\nfunction isHTMLMessage(x: IErrorItem['message']): x is IMessageHTML {\n  return (x as any).text !== undefined\n}\n"]}


--------------------------------------------------------------------------------
/lib/interactive-process.js:
--------------------------------------------------------------------------------
  1 | "use strict";
  2 | Object.defineProperty(exports, "__esModule", { value: true });
  3 | const tslib_1 = require("tslib");
  4 | const CP = require("child_process");
  5 | const Queue = require("promise-queue");
  6 | const tkill = require("tree-kill");
  7 | const EventEmitter = require("events");
  8 | const os_1 = require("os");
  9 | if (!Symbol.asyncIterator) {
 10 |     Object.defineProperty(Symbol, 'asyncIterator', {
 11 |         value: Symbol.for('Symbol.asyncIterator'),
 12 |     });
 13 | }
 14 | function debug(...args) {
 15 |     if (window['atom-haskell-interactive-process-debug'] === true) {
 16 |         console.debug(...args);
 17 |     }
 18 | }
 19 | class InteractiveProcess {
 20 |     constructor(cmd, args, onDidExit, opts, endPattern) {
 21 |         this.events = new EventEmitter();
 22 |         this.endPattern = endPattern;
 23 |         this.requestQueue = new Queue(1, 100);
 24 |         opts.stdio = ['pipe', 'pipe', 'pipe'];
 25 |         try {
 26 |             this.process = CP.spawn(cmd, args, opts);
 27 |             this.process.stdout.setMaxListeners(100);
 28 |             this.process.stderr.setMaxListeners(100);
 29 |             this.process.stdout.setEncoding('utf-8');
 30 |             this.process.stderr.setEncoding('utf-8');
 31 |             this.process.on('exit', (code) => {
 32 |                 if (code !== 0) {
 33 |                     console.error('Process exited abnormally', code);
 34 |                 }
 35 |                 this.process = undefined;
 36 |                 onDidExit(code);
 37 |                 this.destroy();
 38 |             });
 39 |             this.process.on('error', (err) => {
 40 |                 atom.notifications.addError(`Process "${cmd}" failed to start`, {
 41 |                     dismissable: true,
 42 |                     detail: err.toString(),
 43 |                     stack: err.stack,
 44 |                 });
 45 |                 this.process = undefined;
 46 |                 onDidExit(-1);
 47 |                 this.destroy();
 48 |             });
 49 |         }
 50 |         catch (error) {
 51 |             atom.notifications.addFatalError('Error spawning REPL', {
 52 |                 dismissable: true,
 53 |                 stack: error.stack,
 54 |                 detail: `Tried to run "${cmd}" with arguments: ${args}`,
 55 |             });
 56 |             this.destroy();
 57 |         }
 58 |     }
 59 |     async request(command, lineCallback, endPattern = this.endPattern) {
 60 |         return this.requestQueue.add(async () => {
 61 |             var e_1, _a;
 62 |             if (!this.process) {
 63 |                 throw new Error('Interactive process is not running');
 64 |             }
 65 |             this.process.stdout.pause();
 66 |             this.process.stderr.pause();
 67 |             this.writeStdin(command);
 68 |             if (lineCallback) {
 69 |                 lineCallback({ type: 'stdin', line: command });
 70 |             }
 71 |             const res = {
 72 |                 stdout: [],
 73 |                 stderr: [],
 74 |                 prompt: [],
 75 |             };
 76 |             const isEnded = () => res.prompt.length > 0 || this.process === undefined;
 77 |             const stdErrLine = (line) => {
 78 |                 if (lineCallback) {
 79 |                     lineCallback({ type: 'stderr', line });
 80 |                 }
 81 |                 res.stderr.push(line);
 82 |             };
 83 |             const stderr = this.process.stderr;
 84 |             setImmediate(async () => {
 85 |                 var e_2, _a;
 86 |                 try {
 87 |                     for (var _b = tslib_1.__asyncValues(this.readgen(stderr, isEnded)), _c; _c = await _b.next(), !_c.done;) {
 88 |                         const line = _c.value;
 89 |                         debug('stderr', line);
 90 |                         stdErrLine(line);
 91 |                     }
 92 |                 }
 93 |                 catch (e_2_1) { e_2 = { error: e_2_1 }; }
 94 |                 finally {
 95 |                     try {
 96 |                         if (_c && !_c.done && (_a = _b.return)) await _a.call(_b);
 97 |                     }
 98 |                     finally { if (e_2) throw e_2.error; }
 99 |                 }
100 |             });
101 |             let interval = undefined;
102 |             try {
103 |                 interval = window.setInterval(() => process.activateUvLoop(), 100);
104 |                 try {
105 |                     for (var _b = tslib_1.__asyncValues(this.readgen(this.process.stdout, isEnded)), _c; _c = await _b.next(), !_c.done;) {
106 |                         const line = _c.value;
107 |                         debug('stdout', line);
108 |                         const pattern = line.match(endPattern);
109 |                         if (pattern) {
110 |                             if (lineCallback) {
111 |                                 lineCallback({ type: 'prompt', prompt: pattern });
112 |                             }
113 |                             res.prompt = pattern;
114 |                         }
115 |                         else {
116 |                             if (lineCallback) {
117 |                                 lineCallback({ type: 'stdout', line });
118 |                             }
119 |                             res.stdout.push(line);
120 |                         }
121 |                     }
122 |                 }
123 |                 catch (e_1_1) { e_1 = { error: e_1_1 }; }
124 |                 finally {
125 |                     try {
126 |                         if (_c && !_c.done && (_a = _b.return)) await _a.call(_b);
127 |                     }
128 |                     finally { if (e_1) throw e_1.error; }
129 |                 }
130 |                 const restErr = this.process.stderr.read();
131 |                 if (restErr) {
132 |                     restErr.split('\n').forEach(stdErrLine);
133 |                 }
134 |                 this.process.stdout.resume();
135 |                 this.process.stderr.resume();
136 |                 return res;
137 |             }
138 |             catch (e) {
139 |                 console.error(e, res);
140 |                 atom.notifications.addError(`Process crashed while running request`, {
141 |                     detail: `\
142 | stderr:
143 | ${res.stderr.join('\n')}
144 | stdout:
145 | ${res.stdout.join('\n')}
146 | request:
147 | ${command}
148 | `,
149 |                     dismissable: true,
150 |                     stack: e.stack,
151 |                 });
152 |                 throw e;
153 |             }
154 |             finally {
155 |                 if (interval !== undefined)
156 |                     window.clearInterval(interval);
157 |             }
158 |         });
159 |     }
160 |     destroy() {
161 |         if (this.process) {
162 |             tkill(this.process.pid, 'SIGTERM');
163 |             this.process = undefined;
164 |         }
165 |         this.events.emit('destroyed');
166 |     }
167 |     interrupt() {
168 |         if (this.process) {
169 |             tkill(this.process.pid, 'SIGINT');
170 |         }
171 |     }
172 |     isBusy() {
173 |         return this.requestQueue.getPendingLength() > 0;
174 |     }
175 |     writeStdin(str) {
176 |         if (!this.process) {
177 |             throw new Error('Interactive process is not running');
178 |         }
179 |         debug('request', str);
180 |         this.process.stdin.write(str);
181 |     }
182 |     async waitReadable(stream) {
183 |         return new Promise((resolve, reject) => {
184 |             if (!this.process)
185 |                 return reject(new Error('No process'));
186 |             const removeListeners = () => {
187 |                 this.events.removeListener('destroyed', rejectError);
188 |                 stream.removeListener('readable', resolv);
189 |             };
190 |             const rejectError = () => {
191 |                 removeListeners();
192 |                 const err = new Error('Process destroyed while awaiting stream readable');
193 |                 err.destroyed = true;
194 |                 reject(err);
195 |             };
196 |             const resolv = () => {
197 |                 removeListeners();
198 |                 resolve();
199 |             };
200 |             this.events.once('destroyed', rejectError);
201 |             stream.once('readable', resolv);
202 |         });
203 |     }
204 |     readgen(out, isEnded) {
205 |         return tslib_1.__asyncGenerator(this, arguments, function* readgen_1() {
206 |             let buffer = '';
207 |             while (!isEnded()) {
208 |                 const read = out.read();
209 |                 if (read != null) {
210 |                     buffer += read;
211 |                     if (buffer.match(os_1.EOL)) {
212 |                         const arr = buffer.split(os_1.EOL);
213 |                         buffer = arr.pop() || '';
214 |                         yield tslib_1.__await(yield* tslib_1.__asyncDelegator(tslib_1.__asyncValues(arr)));
215 |                     }
216 |                 }
217 |                 else {
218 |                     try {
219 |                         yield tslib_1.__await(this.waitReadable(out));
220 |                     }
221 |                     catch (e) {
222 |                         if (e.destroyed) {
223 |                             console.debug(e);
224 |                             return yield tslib_1.__await(void 0);
225 |                         }
226 |                     }
227 |                 }
228 |             }
229 |             if (buffer) {
230 |                 out.unshift(buffer);
231 |             }
232 |         });
233 |     }
234 | }
235 | exports.InteractiveProcess = InteractiveProcess;
236 | //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"interactive-process.js","sourceRoot":"","sources":["../src/interactive-process.ts"],"names":[],"mappings":"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","sourcesContent":["import * as CP from 'child_process'\nimport Queue = require('promise-queue')\nimport tkill = require('tree-kill')\nimport EventEmitter = require('events')\nimport { EOL } from 'os'\n\nif (!Symbol.asyncIterator) {\n  Object.defineProperty(Symbol, 'asyncIterator', {\n    value: Symbol.for('Symbol.asyncIterator'),\n  })\n}\n\nexport type ExitCallback = (exitCode: number | null) => void\n\nexport interface IRequestResult {\n  stdout: string[]\n  stderr: string[]\n  prompt: RegExpMatchArray\n}\nexport interface ILineIO {\n  type: 'stdin' | 'stdout' | 'stderr'\n  line: string\n}\nexport interface ILinePrompt {\n  type: 'prompt'\n  prompt: RegExpMatchArray\n}\nexport type TLineType = ILineIO | ILinePrompt\nexport type TLineCallback = (line: TLineType) => void\n\nfunction debug(...args: string[]) {\n  if (window['atom-haskell-interactive-process-debug'] === true) {\n    console.debug(...args)\n  }\n}\n\nexport class InteractiveProcess {\n  private process?: CP.ChildProcess\n  private requestQueue: Queue\n  private endPattern: RegExp\n  private events = new EventEmitter()\n  constructor(\n    cmd: string,\n    args: string[],\n    onDidExit: ExitCallback,\n    opts: CP.SpawnOptions,\n    endPattern: RegExp,\n  ) {\n    this.endPattern = endPattern\n    this.requestQueue = new Queue(1, 100)\n\n    opts.stdio = ['pipe', 'pipe', 'pipe']\n\n    try {\n      this.process = CP.spawn(cmd, args, opts)\n      this.process.stdout.setMaxListeners(100)\n      this.process.stderr.setMaxListeners(100)\n      this.process.stdout.setEncoding('utf-8')\n      this.process.stderr.setEncoding('utf-8')\n\n      this.process.on('exit', (code) => {\n        if (code !== 0) {\n          console.error('Process exited abnormally', code)\n        }\n        this.process = undefined\n        onDidExit(code)\n        this.destroy()\n      })\n      this.process.on('error', (err) => {\n        atom.notifications.addError(`Process \"${cmd}\" failed to start`, {\n          dismissable: true,\n          detail: err.toString(),\n          stack: (err as Error).stack,\n        })\n        this.process = undefined\n        onDidExit(-1)\n        this.destroy()\n      })\n    } catch (error) {\n      atom.notifications.addFatalError('Error spawning REPL', {\n        dismissable: true,\n        stack: error.stack,\n        detail: `Tried to run \"${cmd}\" with arguments: ${args}`,\n      })\n      this.destroy()\n    }\n  }\n\n  public async request(\n    command: string,\n    lineCallback?: TLineCallback,\n    endPattern: RegExp = this.endPattern,\n  ): Promise<IRequestResult> {\n    return this.requestQueue.add(async () => {\n      if (!this.process) {\n        throw new Error('Interactive process is not running')\n      }\n\n      this.process.stdout.pause()\n      this.process.stderr.pause()\n\n      this.writeStdin(command)\n      if (lineCallback) {\n        lineCallback({ type: 'stdin', line: command })\n      }\n\n      const res: IRequestResult = {\n        stdout: [],\n        stderr: [],\n        prompt: [],\n      }\n\n      const isEnded = () => res.prompt.length > 0 || this.process === undefined\n\n      const stdErrLine = (line: string) => {\n        if (lineCallback) {\n          lineCallback({ type: 'stderr', line })\n        }\n        res.stderr.push(line)\n      }\n\n      const stderr = this.process.stderr\n      setImmediate(async () => {\n        for await (const line of this.readgen(stderr, isEnded)) {\n          debug('stderr', line)\n          stdErrLine(line)\n        }\n      })\n      let interval = undefined\n      try {\n        interval = window.setInterval(() => process.activateUvLoop(), 100)\n        for await (const line of this.readgen(this.process.stdout, isEnded)) {\n          debug('stdout', line)\n          const pattern = line.match(endPattern)\n          if (pattern) {\n            if (lineCallback) {\n              lineCallback({ type: 'prompt', prompt: pattern })\n            }\n            res.prompt = pattern\n          } else {\n            if (lineCallback) {\n              lineCallback({ type: 'stdout', line })\n            }\n            res.stdout.push(line)\n          }\n        }\n        // tslint:disable-next-line:no-unsafe-any\n        const restErr: string = this.process.stderr.read()\n        if (restErr) {\n          restErr.split('\\n').forEach(stdErrLine)\n        }\n        this.process.stdout.resume()\n        this.process.stderr.resume()\n        return res\n      } catch (e) {\n        console.error(e, res)\n        atom.notifications.addError(`Process crashed while running request`, {\n          detail: `\\\nstderr:\n${res.stderr.join('\\n')}\nstdout:\n${res.stdout.join('\\n')}\nrequest:\n${command}\n`,\n          dismissable: true,\n          stack: (e as Error).stack,\n        })\n        throw e\n      } finally {\n        if (interval !== undefined) window.clearInterval(interval)\n      }\n    })\n  }\n\n  public destroy() {\n    if (this.process) {\n      tkill(this.process.pid, 'SIGTERM')\n      this.process = undefined\n    }\n    this.events.emit('destroyed')\n  }\n\n  public interrupt() {\n    if (this.process) {\n      tkill(this.process.pid, 'SIGINT')\n    }\n  }\n\n  public isBusy() {\n    return this.requestQueue.getPendingLength() > 0\n  }\n\n  public writeStdin(str: string) {\n    if (!this.process) {\n      throw new Error('Interactive process is not running')\n    }\n    debug('request', str)\n    this.process.stdin.write(str)\n  }\n\n  private async waitReadable(stream: NodeJS.ReadableStream) {\n    return new Promise((resolve, reject) => {\n      if (!this.process) return reject(new Error('No process'))\n      const removeListeners = () => {\n        this.events.removeListener('destroyed', rejectError)\n        stream.removeListener('readable', resolv)\n      }\n      const rejectError = () => {\n        removeListeners()\n        const err = new Error(\n          'Process destroyed while awaiting stream readable',\n        ) as any\n        err.destroyed = true\n        reject(err)\n      }\n      const resolv = () => {\n        removeListeners()\n        resolve()\n      }\n      this.events.once('destroyed', rejectError)\n      stream.once('readable', resolv)\n    })\n  }\n\n  private async *readgen(out: NodeJS.ReadableStream, isEnded: () => boolean) {\n    let buffer = ''\n    while (!isEnded()) {\n      const read = out.read()\n      // tslint:disable-next-line: no-null-keyword strict-type-predicates\n      if (read != null) {\n        buffer += read\n        if (buffer.match(EOL)) {\n          const arr = buffer.split(EOL)\n          buffer = arr.pop() || ''\n          yield* arr\n        }\n      } else {\n        try {\n          await this.waitReadable(out)\n        } catch (e) {\n          if (e.destroyed) {\n            console.debug(e)\n            return\n          }\n        }\n      }\n    }\n    if (buffer) {\n      out.unshift(buffer)\n    }\n  }\n}\n"]}


--------------------------------------------------------------------------------