Merge branch 'steps-from-stepdefs-only'

ARCHITECTURE.md

@@ -21,23 +21,23 @@ that are consumed by the Language Service API.
 | source code        |               |
 +----------+---------+               |
            |                         |
-+----------v---------+       +-------v-------+
-|    tree|sitter     |       | Gherkin Parser|
-+----------+---------+       +-------+-------+
++----------v---------+       +-------v--------+
+|    tree-sitter     |       | Gherkin Parser |
++----------+---------+       +-------+--------+
            |                         |
 +----------v---------+       +-------v-------+
 |    Expressions     |       | Gherkin Steps |
 +----------+---------+       +-------+-------+
            |                         |
            +-------------+-----------+
                          |
-               +---------v----------+
-               | buildStepDocuments |
-               +---------+----------+
+               +---------v--------+
+               | buildSuggestions |
+               +---------+--------+
                          |
-                 +-------v--------+
-                 | Step Documents |
-                 +-------+--------+
+                  +------v------+
+                  | Suggestions |
+                  +------+------+
                          |
                  +-------v-------+
                  |     Index     |
@@ -49,7 +49,7 @@ from Java/Ruby/TypeScript/JavaScript/etc. source code using [tree-sitter](https:
 
 Gherkin steps are extracted from Gherkin source code using the Gherkin parser.
 
-Expressions and steps are passed to `buildStepDocuments` to produce an array of `StepDocument`, and these are used to update
+Expressions and steps are passed to `buildSuggestions` to produce an array of `Suggestion`, and these are used to update
 a (search) `Index`.
 
 ## Language Service API

CHANGELOG.md

@@ -11,6 +11,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 - Generate suggestions for Cucumber Expressions even if there are no matching steps. ([#16](https://github.com/cucumber/language-service/issues/16), [#32](https://github.com/cucumber/language-service/pull/32))
 
 ### Changed
+- Renamed `StepDocument` to `Suggestion`
 - The `ExpressionBuilder` constructor has changed. Consumers must provide a `ParserAdpater` - currently a `NodeParserAdapter` is the only implementation.
 
 ### Removed

src/index.ts

@@ -2,5 +2,5 @@ export * from './gherkin/index.js'
 export * from './index/index.js'
 export * from './messages/index.js'
 export * from './service/index.js'
-export * from './step-documents/index.js'
+export * from './suggestions/index.js'
 export * from './tree-sitter/index.js'

src/index/bruteForceIndex.ts

@@ -1,23 +1,21 @@
-import { StepDocument } from '../step-documents/types'
+import { Suggestion } from '../suggestions/types.js'
 import { Index } from './types'
 
 /**
  * A brute force (not very performant or fuzzy-search capable) index that matches permutation expressions with string.includes()
  *
- * @param stepDocuments
+ * @param suggestions
  */
-export function bruteForceIndex(stepDocuments: readonly StepDocument[]): Index {
+export function bruteForceIndex(suggestions: readonly Suggestion[]): Index {
   return (text) => {
     if (!text) return []
     const predicate = (segment: string) => segment.toLowerCase().includes(text.toLowerCase())
-    return stepDocuments.filter((permutationExpression) =>
-      matches(permutationExpression, predicate)
-    )
+    return suggestions.filter((permutationExpression) => matches(permutationExpression, predicate))
   }
 }
 
-function matches(stepDocument: StepDocument, predicate: (segment: string) => boolean): boolean {
-  return !!stepDocument.segments.find((segment) =>
+function matches(suggestion: Suggestion, predicate: (segment: string) => boolean): boolean {
+  return !!suggestion.segments.find((segment) =>
     typeof segment === 'string' ? predicate(segment) : !!segment.find(predicate)
   )
 }

src/index/fuseIndex.ts

@@ -1,16 +1,16 @@
 import Fuse from 'fuse.js'
 
-import { StepDocument } from '../step-documents/types.js'
+import { Suggestion } from '../suggestions/types.js'
 import { Index } from './types.js'
 
 type Doc = {
   text: string
 }
 
-export function fuseIndex(stepDocuments: readonly StepDocument[]): Index {
-  const docs: Doc[] = stepDocuments.map((stepDocument) => {
+export function fuseIndex(suggestions: readonly Suggestion[]): Index {
+  const docs: Doc[] = suggestions.map((suggestion) => {
     return {
-      text: stepDocument.segments
+      text: suggestion.segments
         .map((segment) => (typeof segment === 'string' ? segment : segment.join(' ')))
         .join(''),
     }
@@ -25,6 +25,6 @@ export function fuseIndex(stepDocuments: readonly StepDocument[]): Index {
   return (text) => {
     if (!text) return []
     const results = fuse.search(text, { limit: 10 })
-    return results.map((result) => stepDocuments[result.refIndex])
+    return results.map((result) => suggestions[result.refIndex])
   }
 }

src/index/jsSearchIndex.ts

@@ -1,18 +1,18 @@
 import { Search } from 'js-search'
 
-import { StepDocument } from '../step-documents/types.js'
+import { Suggestion } from '../suggestions/types.js'
 import { Index } from './types.js'
 
 type Doc = {
   id: number
   text: string
 }
 
-export function jsSearchIndex(stepDocuments: readonly StepDocument[]): Index {
-  const docs: Doc[] = stepDocuments.map((stepDocument, id) => {
+export function jsSearchIndex(suggestions: readonly Suggestion[]): Index {
+  const docs: Doc[] = suggestions.map((suggestion, id) => {
     return {
       id,
-      text: stepDocument.segments
+      text: suggestion.segments
         .map((segment) => (typeof segment === 'string' ? segment : segment.join(' ')))
         .join(''),
     }
@@ -25,6 +25,6 @@ export function jsSearchIndex(stepDocuments: readonly StepDocument[]): Index {
   return (text) => {
     if (!text) return []
     const results = search.search(text)
-    return results.map((result: Doc) => stepDocuments[result.id])
+    return results.map((result: Doc) => suggestions[result.id])
   }
 }

src/index/types.ts

@@ -2,8 +2,8 @@
  * A search index function.
  *
  * @param text a text to search for
- * @return results in the form of step documents
+ * @return results in the form of suggestions
  */
-import { StepDocument } from '../step-documents/types.js'
+import { Suggestion } from '../suggestions/types.js'
 
-export type Index = (text: string) => readonly StepDocument[]
+export type Index = (text: string) => readonly Suggestion[]

src/messages/MessagesBuilder.ts

@@ -7,11 +7,11 @@ import {
 import { Envelope, StepDefinitionPatternType } from '@cucumber/messages'
 
 import { extractStepTexts } from '../gherkin/extractStepTexts.js'
-import { buildStepDocuments } from '../step-documents/buildStepDocuments.js'
-import { StepDocument } from '../step-documents/types.js'
+import { buildSuggestions } from '../suggestions/buildSuggestions.js'
+import { Suggestion } from '../suggestions/types.js'
 
 export type MessagesBuilderResult = {
-  stepDocuments: readonly StepDocument[]
+  suggestions: readonly Suggestion[]
   expressions: readonly Expression[]
 }
 
@@ -65,11 +65,7 @@ export class MessagesBuilder {
 
   build(): MessagesBuilderResult {
     return {
-      stepDocuments: buildStepDocuments(
-        this.parameterTypeRegistry,
-        this.stepTexts,
-        this.expressions
-      ),
+      suggestions: buildSuggestions(this.parameterTypeRegistry, this.stepTexts, this.expressions),
       expressions: this.expressions,
     }
   }

src/service/getGherkinCompletionItems.ts

@@ -28,13 +28,13 @@ export function getGherkinCompletionItems(
     },
   })
   if (text === undefined) return []
-  const stepDocuments = index(text)
-  return stepDocuments.map((stepDocument) => ({
-    label: stepDocument.suggestion,
+  const suggestions = index(text)
+  return suggestions.map((suggestion) => ({
+    label: suggestion.label,
     insertTextFormat: InsertTextFormat.Snippet,
     kind: CompletionItemKind.Text,
     textEdit: {
-      newText: lspCompletionSnippet(stepDocument.segments),
+      newText: lspCompletionSnippet(suggestion.segments),
       range: {
         start: {
           line,

src/service/snippet/lspCompletionSnippet.ts

@@ -3,11 +3,11 @@
  *
  * @param expression the expression to generate the snippet from
  */
-import { StepSegments } from '../../step-documents/types.js'
+import { SuggestionSegments } from '../../suggestions/types.js'
 
-export function lspCompletionSnippet(stepSegments: StepSegments): string {
+export function lspCompletionSnippet(segments: SuggestionSegments): string {
   let n = 1
-  return stepSegments
+  return segments
     .map((segment) => (Array.isArray(segment) ? lspPlaceholder(n++, segment) : segment))
     .join('')
 }

src/step-documents/buildStepDocumentFromCucumberExpression.ts → src/suggestions/buildSuggestionFromCucumberExpression.ts

@@ -7,26 +7,26 @@ import {
 } from '@cucumber/cucumber-expressions'
 
 import { makeKey } from './helpers.js'
-import { ParameterChoices, StepDocument, StepSegments } from './types.js'
+import { ParameterChoices, Suggestion, SuggestionSegments } from './types.js'
 
-export function buildStepDocumentFromCucumberExpression(
+export function buildSuggestionFromCucumberExpression(
   expression: CucumberExpression,
   registry: ParameterTypeRegistry,
   parameterChoices: ParameterChoices
-): StepDocument {
+): Suggestion {
   const compiledSegments = compile(expression.ast, registry, parameterChoices)
   const segments = flatten(compiledSegments)
   return {
-    suggestion: expression.source,
+    label: expression.source,
     segments,
   }
 }
 
 type CompileResult = string | readonly CompileResult[]
 
-function flatten(cr: CompileResult): StepSegments {
+function flatten(cr: CompileResult): SuggestionSegments {
   if (typeof cr === 'string') return [cr]
-  return cr.reduce<StepSegments>((prev, curr) => {
+  return cr.reduce<SuggestionSegments>((prev, curr) => {
     const last = prev[prev.length - 1]
     if (typeof curr === 'string') {
       if (typeof last === 'string') {

src/step-documents/buildStepDocuments.ts → src/suggestions/buildSuggestions.ts

@@ -5,26 +5,26 @@ import {
   RegularExpression,
 } from '@cucumber/cucumber-expressions'
 
-import { buildStepDocumentFromCucumberExpression } from './buildStepDocumentFromCucumberExpression.js'
-import { buildStepDocumentsFromRegularExpression } from './buildStepDocumentsFromRegularExpression.js'
+import { buildSuggestionFromCucumberExpression } from './buildSuggestionFromCucumberExpression.js'
+import { buildSuggestionsFromRegularExpression } from './buildSuggestionsFromRegularExpression.js'
 import { makeKey } from './helpers.js'
-import { StepDocument } from './types.js'
+import { Suggestion } from './types.js'
 
 /**
- * Builds an array of {@link StepDocument} from steps and step definitions.
+ * Builds an array of {@link Suggestion} from steps and step definitions.
  *
- * @param parameterTypeRegistry
+ * @param registry
  * @param stepTexts
  * @param expressions
  * @param maxChoices
  */
-export function buildStepDocuments(
-  parameterTypeRegistry: ParameterTypeRegistry,
+export function buildSuggestions(
+  registry: ParameterTypeRegistry,
   stepTexts: readonly string[],
   expressions: readonly Expression[],
   maxChoices = 10
-): readonly StepDocument[] {
-  let stepDocuments: StepDocument[] = []
+): readonly Suggestion[] {
+  let suggestions: Suggestion[] = []
 
   const parameterChoiceSets: Record<string, Set<string>> = {}
 
@@ -55,20 +55,15 @@ export function buildStepDocuments(
 
   for (const expression of expressions) {
     if (expression instanceof CucumberExpression) {
-      stepDocuments = stepDocuments.concat(
-        buildStepDocumentFromCucumberExpression(expression, parameterTypeRegistry, parameterChoices)
+      suggestions = suggestions.concat(
+        buildSuggestionFromCucumberExpression(expression, registry, parameterChoices)
       )
     }
     if (expression instanceof RegularExpression) {
-      stepDocuments = stepDocuments.concat(
-        buildStepDocumentsFromRegularExpression(
-          expression,
-          parameterTypeRegistry,
-          stepTexts,
-          parameterChoices
-        )
+      suggestions = suggestions.concat(
+        buildSuggestionsFromRegularExpression(expression, registry, stepTexts, parameterChoices)
       )
     }
   }
-  return stepDocuments.sort((a, b) => a.suggestion.localeCompare(b.suggestion))
+  return suggestions.sort((a, b) => a.label.localeCompare(b.label))
 }

src/step-documents/buildStepDocumentsFromRegularExpression.ts → src/suggestions/buildSuggestionsFromRegularExpression.ts

@@ -1,20 +1,20 @@
 import { ParameterTypeRegistry, RegularExpression } from '@cucumber/cucumber-expressions'
 
-import { ParameterChoices, StepDocument, StepSegment } from './types'
+import { ParameterChoices, Suggestion, SuggestionSegment } from './types'
 
-export function buildStepDocumentsFromRegularExpression(
+export function buildSuggestionsFromRegularExpression(
   expression: RegularExpression,
   registry: ParameterTypeRegistry,
   stepTexts: readonly string[],
   parameterChoices: ParameterChoices
-): StepDocument[] {
+): readonly Suggestion[] {
   const segmentJsons = new Set<string>()
 
   for (const text of stepTexts) {
     const args = expression.match(text)
     if (args) {
       const parameterTypes = args.map((arg) => arg.getParameterType())
-      const segments: StepSegment[] = []
+      const segments: SuggestionSegment[] = []
       let index = 0
       for (let argIndex = 0; argIndex < args.length; argIndex++) {
         const arg = args[argIndex]
@@ -37,7 +37,7 @@ export function buildStepDocumentsFromRegularExpression(
     }
   }
   return [...segmentJsons].sort().map((s, n) => ({
-    segments: JSON.parse(s) as StepSegment[],
-    suggestion: n == 0 ? expression.source : `${expression.source} (${n + 1})`,
+    segments: JSON.parse(s) as SuggestionSegment[],
+    label: n == 0 ? expression.source : `${expression.source} (${n + 1})`,
   }))
 }

src/suggestions/index.ts

@@ -0,0 +1,2 @@
+export * from './buildSuggestions.js'
+export * from './types.js'