effect-bdd 0.1.1 → 0.1.3

package/src/internal/cli/tagExpression.ts

@@ -1,173 +0,0 @@
-import * as Arr from "effect/Array"
-import * as Effect from "effect/Effect"
-import { pipe } from "effect/Function"
-import * as Str from "effect/String"
-import { DiscoveryError } from "./errors.ts"
-
-/** @internal */
-export type TagPredicate = (tags: ReadonlyArray<string>) => boolean
-
-type Expression =
-  | {
-    readonly _tag: "Tag"
-    readonly tag: string
-  }
-  | {
-    readonly _tag: "Not"
-    readonly expression: Expression
-  }
-  | {
-    readonly _tag: "And"
-    readonly left: Expression
-    readonly right: Expression
-  }
-  | {
-    readonly _tag: "Or"
-    readonly left: Expression
-    readonly right: Expression
-  }
-
-interface ParseResult {
-  readonly expression: Expression
-  readonly index: number
-}
-
-/** @internal */
-export const compileAll = (
-  expressions: ReadonlyArray<string>
-): Effect.Effect<TagPredicate, DiscoveryError> =>
-  Effect.forEach(expressions, compile).pipe(
-    Effect.map((predicates) => (tags) => Arr.every(predicates, (predicate) => predicate(tags)))
-  )
-
-const compile = (expression: string): Effect.Effect<TagPredicate, DiscoveryError> => {
-  const tokens = tokenize(expression)
-  if (tokens === undefined || tokens.length === 0) {
-    return fail(expression, "Expected a tag expression")
-  }
-  const result = parseOr(tokens, 0)
-  if (result === undefined || result.index !== tokens.length) {
-    return fail(expression, "Could not parse tag expression")
-  }
-  return Effect.succeed((tags) => evaluate(result.expression, tags))
-}
-
-const parseOr = (tokens: ReadonlyArray<string>, index: number): ParseResult | undefined => {
-  const left = parseAnd(tokens, index)
-  if (left === undefined) {
-    return undefined
-  }
-  return parseOrRest(tokens, left)
-}
-
-const parseOrRest = (tokens: ReadonlyArray<string>, left: ParseResult): ParseResult => {
-  if (tokens[left.index] !== "or") {
-    return left
-  }
-  const right = parseAnd(tokens, left.index + 1)
-  if (right === undefined) {
-    return left
-  }
-  return parseOrRest(tokens, {
-    expression: {
-      _tag: "Or",
-      left: left.expression,
-      right: right.expression
-    },
-    index: right.index
-  })
-}
-
-const parseAnd = (tokens: ReadonlyArray<string>, index: number): ParseResult | undefined => {
-  const left = parseUnary(tokens, index)
-  if (left === undefined) {
-    return undefined
-  }
-  return parseAndRest(tokens, left)
-}
-
-const parseAndRest = (tokens: ReadonlyArray<string>, left: ParseResult): ParseResult => {
-  if (tokens[left.index] !== "and") {
-    return left
-  }
-  const right = parseUnary(tokens, left.index + 1)
-  if (right === undefined) {
-    return left
-  }
-  return parseAndRest(tokens, {
-    expression: {
-      _tag: "And",
-      left: left.expression,
-      right: right.expression
-    },
-    index: right.index
-  })
-}
-
-const parseUnary = (tokens: ReadonlyArray<string>, index: number): ParseResult | undefined =>
-  tokens[index] === "not" ? parseNot(tokens, index) : parsePrimary(tokens, index)
-
-const parseNot = (tokens: ReadonlyArray<string>, index: number): ParseResult | undefined => {
-  const result = parseUnary(tokens, index + 1)
-  return result === undefined
-    ? undefined
-    : {
-      expression: {
-        _tag: "Not",
-        expression: result.expression
-      },
-      index: result.index
-    }
-}
-
-const parsePrimary = (tokens: ReadonlyArray<string>, index: number): ParseResult | undefined => {
-  const token = tokens[index]
-  if (token === undefined) {
-    return undefined
-  }
-  if (token === "(") {
-    const result = parseOr(tokens, index + 1)
-    return result !== undefined && tokens[result.index] === ")"
-      ? {
-        expression: result.expression,
-        index: result.index + 1
-      }
-      : undefined
-  }
-  return pipe(token, Str.startsWith("@"))
-    ? {
-      expression: {
-        _tag: "Tag",
-        tag: token
-      },
-      index: index + 1
-    }
-    : undefined
-}
-
-const evaluate = (expression: Expression, tags: ReadonlyArray<string>): boolean => {
-  switch (expression._tag) {
-    case "Tag": {
-      return Arr.contains(expression.tag)(tags)
-    }
-    case "Not": {
-      return !evaluate(expression.expression, tags)
-    }
-    case "And": {
-      return evaluate(expression.left, tags) && evaluate(expression.right, tags)
-    }
-    case "Or": {
-      return evaluate(expression.left, tags) || evaluate(expression.right, tags)
-    }
-  }
-}
-
-const tokenize = (expression: string): ReadonlyArray<string> | undefined => {
-  const matches = expression.match(/\(|\)|\b(?:and|or|not)\b|@[A-Za-z0-9][A-Za-z0-9_-]*/g) ?? []
-  const normalized = pipe(expression, Str.replace(/\s+/g, ""))
-  const matched = pipe(matches, Arr.join(""))
-  return normalized === matched ? matches : undefined
-}
-
-const fail = (expression: string, message: string): Effect.Effect<never, DiscoveryError> =>
-  Effect.fail(new DiscoveryError({ message: `${message}: ${expression}` }))

package/src/internal/cucumberCompiler.ts

@@ -1,58 +0,0 @@
-import { AstBuilder, compile, GherkinClassicTokenMatcher, Parser } from "@cucumber/gherkin"
-import { IdGenerator } from "@cucumber/messages"
-import * as Effect from "effect/Effect"
-import * as Layer from "effect/Layer"
-import { ParseError } from "../Errors.ts"
-import { GherkinCompiler, type ParsedSource } from "./parser.ts"
-
-/** @internal */
-export const Cucumber = Layer.succeed(GherkinCompiler, {
-  compile: (source, uri) =>
-    Effect.try({
-      try: () => compileWithCucumber(source, uri),
-      catch: parseErrorFromCause
-    })
-})
-
-const compileWithCucumber = (source: string, uri: string): ParsedSource => {
-  const newId = IdGenerator.incrementing()
-  const parser = new Parser(new AstBuilder(newId), new GherkinClassicTokenMatcher())
-  const document = parser.parse(source)
-  return {
-    document,
-    pickles: compile(document, uri, newId)
-  }
-}
-
-const parseErrorFromCause = (cause: unknown): ParseError => {
-  const location = causeLocation(cause)
-  return new ParseError({
-    message: causeMessage(cause),
-    line: location?.line ?? 1,
-    column: location?.column ?? 1
-  })
-}
-
-const causeLocation = (cause: unknown): { readonly line: number; readonly column?: number } | undefined => {
-  if (
-    typeof cause === "object" && cause !== null && "errors" in cause && Array.isArray(cause.errors) &&
-    cause.errors.length > 0
-  ) {
-    return causeLocation(cause.errors[0])
-  }
-  if (typeof cause === "object" && cause !== null && "location" in cause) {
-    const location = cause.location
-    if (typeof location === "object" && location !== null && "line" in location && typeof location.line === "number") {
-      return {
-        line: location.line,
-        ...("column" in location && typeof location.column === "number" ? { column: location.column } : {})
-      }
-    }
-  }
-  return undefined
-}
-
-const causeMessage = (cause: unknown): string =>
-  typeof cause === "object" && cause !== null && "message" in cause && typeof cause.message === "string"
-    ? cause.message
-    : String(cause)

package/src/internal/expression.ts

@@ -1,103 +0,0 @@
-import * as Arr from "effect/Array"
-import { pipe } from "effect/Function"
-import * as Option from "effect/Option"
-import * as Record from "effect/Record"
-import * as Schema from "effect/Schema"
-import * as Str from "effect/String"
-
-/** @internal */
-export interface Capture<Name extends string, A> {
-  readonly _tag: "Capture"
-  readonly name: Name
-  readonly schema: Schema.Codec<A, string>
-}
-
-/** @internal */
-export interface Matcher<A> {
-  readonly source: string
-  readonly match: (text: string) => Option.Option<A>
-}
-
-interface MatcherState {
-  readonly names: ReadonlyArray<string>
-  readonly captures: ReadonlyArray<Capture<string, unknown>>
-  readonly source: string
-  readonly pattern: string
-}
-
-/** @internal */
-export const makeCapture = <const Name extends string, A>(
-  name: Name,
-  schema: Schema.Codec<A, string>
-): Capture<Name, A> => ({
-  _tag: "Capture",
-  name,
-  schema
-})
-
-/** @internal */
-export const makeMatcher = <A>(
-  strings: TemplateStringsArray,
-  captures: ReadonlyArray<Capture<string, unknown>>
-): Matcher<A> => {
-  const state = pipe(
-    strings,
-    Arr.reduce(initialMatcherState, (state, literal, index) => appendTemplatePart(state, literal, captures[index]))
-  )
-  const regex = new globalThis.RegExp(`${state.pattern}$`)
-  const decoders = Arr.map(state.captures, (capture) => Schema.decodeUnknownOption(capture.schema))
-
-  return {
-    source: state.source,
-    match(text) {
-      const match = regex.exec(text)
-      if (match === null) {
-        return Option.none()
-      }
-      return Option.map(decodeCaptures(state.names, decoders, match), (out) => out as A)
-    }
-  }
-}
-
-const initialMatcherState: MatcherState = {
-  names: [],
-  captures: [],
-  source: "",
-  pattern: "^"
-}
-
-const appendTemplatePart = (
-  state: MatcherState,
-  literal: string,
-  capture: Capture<string, unknown> | undefined
-): MatcherState => {
-  const pattern = `${state.pattern}${escapeRegExp(literal)}`
-  const source = `${state.source}${literal}`
-  if (capture === undefined) {
-    return { ...state, pattern, source }
-  }
-  return {
-    names: Arr.append(state.names, capture.name),
-    captures: Arr.append(state.captures, capture),
-    pattern: `${pattern}(.+?)`,
-    source: `${source}{${capture.name}}`
-  }
-}
-
-const decodeCaptures = (
-  names: ReadonlyArray<string>,
-  decoders: ReadonlyArray<(input: unknown) => Option.Option<unknown>>,
-  match: RegExpExecArray,
-  index = 0,
-  out: Record<string, unknown> = Record.empty()
-): Option.Option<Record<string, unknown>> => {
-  if (index >= names.length) {
-    return Option.some(out)
-  }
-  return pipe(
-    decoders[index](match[index + 1]),
-    Option.flatMap((value) => decodeCaptures(names, decoders, match, index + 1, Record.set(out, names[index], value)))
-  )
-}
-
-const escapeRegExp = Str.replace(/[/\\^$*+?.()|[\]{}]/g, "\\$&")

package/src/internal/matching.ts

@@ -1,81 +0,0 @@
-import { type PickleStep, PickleStepType } from "@cucumber/messages"
-import * as Arr from "effect/Array"
-import { pipe } from "effect/Function"
-import * as Option from "effect/Option"
-
-/** @internal */
-export type StepKind = "Step" | "Given" | "When" | "Then"
-
-/** @internal */
-export type ConcreteStepKind = "Given" | "When" | "Then"
-
-/** @internal */
-export interface MatchableTransition {
-  readonly kind: StepKind
-  readonly expression: {
-    readonly source: string
-    readonly match: (text: string) => Option.Option<unknown>
-  }
-}
-
-/** @internal */
-export interface MatchedTransition<Transition extends MatchableTransition> {
-  readonly transition: Transition
-  readonly captures: unknown
-}
-
-/** @internal */
-export const matchingTextTransitions = <Transition extends MatchableTransition>(
-  transitions: ReadonlyArray<Transition>,
-  text: string
-): ReadonlyArray<MatchedTransition<Transition>> =>
-  pipe(
-    transitions,
-    Arr.map((transition): Option.Option<MatchedTransition<Transition>> =>
-      pipe(
-        transition.expression.match(text),
-        Option.map((captures) => ({ transition, captures }))
-      )
-    ),
-    Arr.getSomes
-  )
-
-/** @internal */
-export const matchingKeywordTransitions = <Transition extends MatchableTransition>(
-  transitions: ReadonlyArray<MatchedTransition<Transition>>,
-  kind: ConcreteStepKind
-): ReadonlyArray<MatchedTransition<Transition>> =>
-  Arr.filter(transitions, (match) => keywordMatches(match.transition.kind, kind))
-
-/** @internal */
-export const keywordMatches = (transition: StepKind, keyword: ConcreteStepKind): boolean =>
-  transition === "Step" || transition === keyword
-
-/** @internal */
-export const concreteStepKind = (step: PickleStep): Option.Option<ConcreteStepKind> => {
-  switch (step.type) {
-    case PickleStepType.CONTEXT: {
-      return Option.some("Given")
-    }
-    case PickleStepType.ACTION: {
-      return Option.some("When")
-    }
-    case PickleStepType.OUTCOME: {
-      return Option.some("Then")
-    }
-    default: {
-      return Option.none()
-    }
-  }
-}
-
-/** @internal */
-export const renderTransitionKinds = <Transition extends MatchableTransition>(
-  transitions: ReadonlyArray<Transition>
-): string =>
-  pipe(
-    transitions,
-    Arr.map((transition) => transition.kind),
-    Arr.dedupe,
-    Arr.join(", ")
-  )

package/src/internal/parser.ts

@@ -1,155 +0,0 @@
-import type {
-  Background as CucumberBackground,
-  GherkinDocument,
-  Pickle,
-  Rule as CucumberRule,
-  Scenario as CucumberScenario,
-  Step as CucumberStep
-} from "@cucumber/messages"
-import * as Context from "effect/Context"
-import * as Effect from "effect/Effect"
-import { pipe } from "effect/Function"
-import * as Option from "effect/Option"
-import { ParseError } from "../Errors.ts"
-
-/** @internal */
-export type Keyword = "Given" | "When" | "Then" | "And" | "But" | "*"
-
-/** @internal */
-export interface CompiledFeature {
-  readonly name: string
-  readonly line: number
-  readonly pickles: ReadonlyArray<Pickle>
-  readonly source: SourceIndex
-}
-
-/** @internal */
-export interface ParsedSource {
-  readonly document: GherkinDocument
-  readonly pickles: ReadonlyArray<Pickle>
-}
-
-/** @internal */
-export class GherkinCompiler extends Context.Service<GherkinCompiler, {
-  readonly compile: (source: string, uri: string) => Effect.Effect<ParsedSource, ParseError>
-}>()("effect-bdd/GherkinCompiler") {}
-
-/** @internal */
-export interface SourceIndex {
-  readonly steps: ReadonlyMap<string, CucumberStep>
-  readonly scenarios: ReadonlyMap<string, {
-    readonly scenario: CucumberScenario
-    readonly rule: CucumberRule | undefined
-  }>
-}
-
-/** @internal */
-export const parse = (source: string, uri = "<inline>"): Effect.Effect<CompiledFeature, ParseError, GherkinCompiler> =>
-  Effect.flatMap(GherkinCompiler, (compiler) => pipe(compiler.compile(source, uri), Effect.flatMap(toFeature)))
-
-const toFeature: (parsed: ParsedSource) => Effect.Effect<CompiledFeature, ParseError> = Effect.fnUntraced(function*(
-  parsed
-) {
-  const feature = parsed.document.feature
-  if (feature === undefined) {
-    return yield* parseError("Expected a Feature declaration", 1, 1)
-  }
-  if (parsed.pickles.length === 0) {
-    return yield* parseError("Expected at least one Scenario", feature.location.line, feature.location.column ?? 1)
-  }
-
-  const source = indexDocument(parsed.document)
-  return {
-    name: feature.name,
-    line: feature.location.line,
-    pickles: parsed.pickles,
-    source
-  }
-})
-
-const indexDocument = (document: GherkinDocument): SourceIndex => {
-  const steps = new Map<string, CucumberStep>()
-  const scenarios = new Map<string, { readonly scenario: CucumberScenario; readonly rule: CucumberRule | undefined }>()
-  const feature = document.feature
-  if (feature === undefined) {
-    return { steps, scenarios }
-  }
-  for (const child of feature.children) {
-    if (child.background !== undefined) {
-      indexBackground(steps, child.background)
-    }
-    if (child.scenario !== undefined) {
-      indexScenario(steps, scenarios, child.scenario, undefined)
-    }
-    if (child.rule !== undefined) {
-      for (const ruleChild of child.rule.children) {
-        if (ruleChild.background !== undefined) {
-          indexBackground(steps, ruleChild.background)
-        }
-        if (ruleChild.scenario !== undefined) {
-          indexScenario(steps, scenarios, ruleChild.scenario, child.rule)
-        }
-      }
-    }
-  }
-  return { steps, scenarios }
-}
-
-const indexBackground = (steps: Map<string, CucumberStep>, background: CucumberBackground): void => {
-  for (const step of background.steps) {
-    steps.set(step.id, step)
-  }
-}
-
-const indexScenario = (
-  steps: Map<string, CucumberStep>,
-  scenarios: Map<string, { readonly scenario: CucumberScenario; readonly rule: CucumberRule | undefined }>,
-  scenario: CucumberScenario,
-  rule: CucumberRule | undefined
-): void => {
-  scenarios.set(scenario.id, { scenario, rule })
-  for (const step of scenario.steps) {
-    steps.set(step.id, step)
-  }
-}
-
-/** @internal */
-export const findScenario = (pickle: Pickle, index: SourceIndex) =>
-  pipe(
-    pickle.astNodeIds,
-    Option.liftPredicate((ids): ids is ReadonlyArray<string> => ids.length > 0),
-    Option.flatMap(() => Option.fromNullishOr(pickle.astNodeIds.find((id) => index.scenarios.has(id)))),
-    Option.flatMap((id) => Option.fromNullishOr(index.scenarios.get(id)))
-  )
-
-/** @internal */
-export const findStep = (
-  pickleStep: { readonly astNodeIds: ReadonlyArray<string> },
-  index: SourceIndex
-): CucumberStep | undefined =>
-  pickleStep.astNodeIds
-    .map((id) => index.steps.get(id))
-    .find((step) => step !== undefined)
-
-/** @internal */
-export const stepLine = (
-  step: { readonly astNodeIds: ReadonlyArray<string> },
-  index: SourceIndex
-): number => findStep(step, index)?.location.line ?? 1
-
-/** @internal */
-export const stepKeyword = (
-  step: { readonly astNodeIds: ReadonlyArray<string> },
-  index: SourceIndex
-): Keyword => {
-  const source = findStep(step, index)
-  return source === undefined ? "Given" : normalizeKeyword(source.keyword)
-}
-
-const normalizeKeyword = (keyword: string): Keyword => {
-  const trimmed = keyword.trim()
-  return trimmed === "*" ? "*" : trimmed as Keyword
-}
-
-const parseError = (message: string, line: number, column: number): Effect.Effect<never, ParseError> =>
-  Effect.fail(new ParseError({ message, line, column }))