JavaScript Support - Addresses #42

CHANGELOG.md

@@ -6,6 +6,8 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/)
 and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased]
+###Added
+- Added support for JavaScript - [PR](https://github.com/cucumber/language-service/pull/115)
 
 ## [1.3.0] - 2022-11-28
 ### Added

README.md

@@ -15,7 +15,7 @@ and [Cucumber Monaco](https://github.com/cucumber/monaco#readme).
   - [x] PHP
   - [x] Ruby
   - [x] Rust
-  - [ ] [JavaScript](https://github.com/cucumber/language-service/issues/42)
+  - [x] JavaScript
   - [ ] [Python](https://github.com/cucumber/language-service/issues/49)
 - [x] Go to step definition
 - [x] Generate step definition

src/language/javascriptLanguage.ts

@@ -0,0 +1,155 @@
+import { StringOrRegExp } from '@cucumber/cucumber-expressions'
+import { RegExps } from '@cucumber/cucumber-expressions/dist/cjs/src/ParameterType'
+
+import { childrenToString, filter, NO_QUOTES } from './helpers.js'
+import { NO_EXPRESSION } from './SourceAnalyzer.js'
+import { Language, TreeSitterSyntaxNode } from './types.js'
+
+export const javascriptLanguage: Language = {
+  toParameterTypeName(node) {
+    return childrenToString(node, NO_QUOTES)
+  },
+  toParameterTypeRegExps(node) {
+    return toRegExps(node)
+  },
+  toStepDefinitionExpression(node) {
+    return toStringOrRegExp(node)
+  },
+  defineParameterTypeQueries: [
+    `
+(call_expression
+  function: (identifier) @function-name
+  arguments: (arguments
+    (object
+      [
+        (
+          (pair
+            key: (property_identifier) @name-key
+            value: (string) @name
+          )
+          (pair
+            key: (property_identifier) @regexp-key
+            value: [
+              (regex) 
+              (string) 
+              (array
+                [
+                  (regex) 
+                  (string) 
+                ]
+              )
+            ] @expression
+          )
+        )
+        (
+          (pair
+            key: (property_identifier) @regexp-key
+            value: [
+              (regex) 
+              (string) 
+              (array
+                [
+                  (regex) 
+                  (string) 
+                ]
+              )
+            ] @expression
+          )
+          (pair
+            key: (property_identifier) @name-key
+            value: (string) @name
+          )
+        )
+      ]
+    )
+  )
+  (#eq? @function-name "defineParameterType")
+  (#eq? @name-key "name")
+  (#eq? @regexp-key "regexp")
+) @root
+`,
+  ],
+  defineStepDefinitionQueries: [
+    `
+(call_expression
+  function: (identifier) @function-name
+  arguments: (arguments
+    [
+      (string) @expression
+      (regex) @expression
+      (template_string) @expression
+    ]
+  )
+  (#match? @function-name "Given|When|Then")
+) @root
+`,
+  ],
+
+  snippetParameters: {
+    int: { type: 'number' },
+    float: { type: 'number' },
+    word: { type: 'string' },
+    string: { type: 'string', name: 's' },
+    double: { type: 'number' },
+    bigdecimal: { type: 'string', name: 'bigDecimal' },
+    byte: { type: 'number' },
+    short: { type: 'number' },
+    long: { type: 'number' },
+    biginteger: { type: 'BigInt', name: 'bigInt' },
+    '': { type: 'unknown', name: 'arg' },
+  },
+
+  defaultSnippetTemplate: `
+{{ keyword }}('{{ expression }}', ({{ #parameters }}{{ #seenParameter }}, {{ /seenParameter }}{{ name }}{{ /parameters }}) => {
+  // {{ blurb }}
+})
+`,
+}
+
+function toRegExps(node: TreeSitterSyntaxNode | null): RegExps {
+  if (node === null) throw new Error('node cannot be null')
+  switch (node.type) {
+    case 'regex':
+    case 'string':
+      return toStringOrRegExp(node)
+    case 'array':
+      return filter(node, (child) => child.type === 'regex').map(toStringOrRegExp)
+    default:
+      throw new Error(`Unexpected type: ${node.type}`)
+  }
+}
+
+export function toStringOrRegExp(node: TreeSitterSyntaxNode): StringOrRegExp {
+  switch (node.type) {
+    case 'regex': {
+      let flags = ''
+      let flag: string
+      const s = node.text
+      for (let i = s.length - 1; (flag = s[i]) !== '/'; i--) {
+        // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions#advanced_searching_with_flags
+        flags = `${flags}${flag}`
+      }
+      const source = node.children
+        .filter((child) => child.type === 'regex_pattern')
+        .map((node) => node.text)
+        .join('')
+      return new RegExp(unescapeString(source), flags)
+    }
+    case 'string':
+      return unescapeString(childrenToString(node, NO_QUOTES))
+    case 'template_string': {
+      const substitutions = node.children.filter((node) => node.type === 'template_substitution')
+      if (substitutions.length > 0) {
+        // Can't handle template strings with substitutions.
+        return NO_EXPRESSION
+      }
+      return node.text.slice(1, node.text.length - 1)
+    }
+    default:
+      throw new Error(`Unexpected type: ${node.type}`)
+  }
+}
+
+function unescapeString(s: string): string {
+  return s.replace(/\\'/g, "'").replace(/\\"/g, '"')
+}

src/language/languages.ts

@@ -1,5 +1,6 @@
 import { csharpLanguage } from './csharpLanguage.js'
 import { javaLanguage } from './javaLanguage.js'
+import { javascriptLanguage } from './javascriptLanguage.js'
 import { phpLanguage } from './phpLanguage.js'
 import { pythonLanguage } from './pythonLanguage.js'
 import { rubyLanguage } from './rubyLanguage.js'
@@ -15,6 +16,7 @@ const languageByName: Record<LanguageName, Language> = {
   ruby: rubyLanguage,
   rust: rustLanguage,
   python: pythonLanguage,
+  javascript: javascriptLanguage,
 }
 
 export function getLanguage(languageName: LanguageName): Language {

src/language/types.ts

@@ -35,7 +35,16 @@ export type SnippetParameters = Readonly<Record<ParameterTypeName, SnippetParame
 
 export type ParameterTypeMeta = Readonly<{ name: string; regexp: string }>
 
-export const LanguageNames = ['java', 'tsx', 'c_sharp', 'php', 'python', 'ruby', 'rust'] as const
+export const LanguageNames = [
+  'java',
+  'tsx',
+  'c_sharp',
+  'php',
+  'python',
+  'ruby',
+  'rust',
+  'javascript',
+] as const
 export type LanguageName = typeof LanguageNames[number]
 
 export type Source<L> = Readonly<{

src/tree-sitter-node/NodeParserAdapter.ts

@@ -30,6 +30,7 @@ export class NodeParserAdapter implements ParserAdapter {
         this.parser.setLanguage(Java)
         break
       case 'tsx':
+      case 'javascript':
         this.parser.setLanguage(TypeScript.typescript)
         break
       case 'c_sharp':

src/tree-sitter-wasm/WasmParserAdapter.ts

@@ -2,6 +2,14 @@ import WasmParser from 'web-tree-sitter'
 
 import { LanguageName, LanguageNames, ParserAdapter } from '../language/types.js'
 
+type LanguageToWasmMap = {
+  [key in LanguageName]?: Exclude<LanguageName, key>
+}
+
+const languageNameToWasmNameMap: LanguageToWasmMap = {
+  javascript: 'tsx',
+}
+
 export class WasmParserAdapter implements ParserAdapter {
   public parser: WasmParser
   private languages: Record<LanguageName, WasmParser.Language>
@@ -14,6 +22,9 @@ export class WasmParserAdapter implements ParserAdapter {
 
     const languages = await Promise.all(
       LanguageNames.map((languageName) => {
+        const mapToDifferentWasm = languageNameToWasmNameMap[languageName]
+        if (mapToDifferentWasm !== undefined) languageName = mapToDifferentWasm
+
         const wasmUrl = `${this.wasmBaseUrl}/${languageName}.wasm`
         try {
           return WasmParser.Language.load(wasmUrl)

test/language/ExpressionBuilder.test.ts

@@ -13,6 +13,7 @@ import { WasmParserAdapter } from '../../src/tree-sitter-wasm/WasmParserAdapter.
 const cucumberExpressionsSupport: Set<LanguageName> = new Set([
   'c_sharp',
   'java',
+  'javascript',
   'python',
   'ruby',
   'rust',
@@ -73,7 +74,6 @@ function defineContract(makeParserAdapter: () => ParserAdapter) {
             link.targetSelectionRange.end.character <= link.targetRange.end.character
         )
       }
-
       const expressions = result.expressionLinks.map(({ expression }) =>
         expression instanceof CucumberExpression
           ? expression.source

test/language/testdata/javascript/ParameterTypes.js

@@ -0,0 +1,19 @@
+import { defineParameterType } from '@cucumber/cucumber'
+
+defineParameterType({
+  name: 'planet',
+  regexp: [/jupiter/, /mars/, /tellus/],
+  transformer: (name) => name,
+})
+
+defineParameterType({
+  name: 'uuid',
+  regexp: /[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}/,
+  transformer: (uuid) => uuid,
+})
+
+defineParameterType({
+  name: 'date',
+  regexp: /\d{4}-\d{2}-\d{2}/,
+  transformer: (name) => new Date(name),
+})

test/language/testdata/javascript/StepDefinitions.js

@@ -0,0 +1,29 @@
+import { Given } from '@cucumber/cucumber'
+import assert from 'assert'
+import React from 'react'
+
+const dummyJsx = <span>Hello</span>
+
+Given('a {uuid}', async function (uuid) {
+  assert(uuid)
+})
+
+Given('a {date}', async function (date) {
+  assert(date)
+})
+
+Given('a {planet}', async function (planet) {
+  assert(planet)
+})
+
+Given(/^a regexp$/, async function () {
+  assert(true)
+})
+
+Given('an {undefined-parameter}', async function (date) {
+  assert(date)
+})
+
+Given("the bee's knees", async function () {
+  assert(true)
+})