Cerberus.Locator (cerberus v0.1.7)

Normalize user input into a canonical locator AST.

The AST supports:

leaf locators (:text, :label, :css, :testid, ...)
composition (:scope, :and, :or, :not)
descendant/state filters via filter/2 (:has, :has_not, and :visible)
closest-scope input via :from
regex text values for text-like locators and role names (without :exact)

Summary

Types

composite_kind()

composite_value()

leaf_kind()

locator_kind()

normalize_result()

resolved_role_kind()

role_kind()

t()

Functions

closest(locator, opts)

compose_and(left, right)

compose_not(locator)

compose_or(left, right)

compose_scope(left, right)

contains_has_filter?(locator)

contains_kind?(locator, kind)

filter(locator, opts)

leaf(kind, value, opts \\ [])

normalize(locator)

Normalizes locators and returns {:ok, locator} or {:error, reason}.

normalize!(locator)

Normalizes locators and raises Cerberus.InvalidLocatorError on invalid input.

put_from(locator, from_locator)

resolve_role_kind(role)

resolve_role_kind!(role, original)

resolved_kind(locator)

role(role, opts \\ [])

sigil(value, modifiers)

text_sigil(value)

Types

composite_kind()

@type composite_kind() :: :scope | :and | :or | :not

composite_value()

@type composite_value() :: [t()]

leaf_kind()

@type leaf_kind() :: :text | :label | :placeholder | :title | :alt | :testid | :css

locator_kind()

@type locator_kind() :: leaf_kind() | role_kind() | composite_kind()

normalize_result()

@type normalize_result() :: {:ok, t()} | {:error, Exception.t()}

resolved_role_kind()

@type resolved_role_kind() :: :text | :label | :link | :button | :alt

role_kind()

@type role_kind() :: :role

t()

@type t() :: %Cerberus.Locator{
  kind: locator_kind(),
  opts: keyword(),
  value: String.t() | Regex.t() | composite_value()
}

Functions

closest(locator, opts)

@spec closest(t(), Cerberus.Options.closest_opts()) :: t()

compose_and(left, right)

@spec compose_and(t(), t()) :: t()

compose_not(locator)

@spec compose_not(t()) :: t()

compose_or(left, right)

@spec compose_or(t(), t()) :: t()

compose_scope(left, right)

@spec compose_scope(t(), t()) :: t()

contains_has_filter?(locator)

@spec contains_has_filter?(t()) :: boolean()

contains_kind?(locator, kind)

@spec contains_kind?(t(), locator_kind()) :: boolean()

filter(locator, opts)

@spec filter(
  t(),
  keyword()
) :: t()

leaf(kind, value, opts \\ [])

@spec leaf(leaf_kind(), String.t() | Regex.t(), Cerberus.Options.locator_leaf_opts()) ::
  t()

normalize(locator)

@spec normalize(t()) :: normalize_result()

Normalizes locators and returns {:ok, locator} or {:error, reason}.

normalize!(locator)

@spec normalize!(t()) :: t()

Normalizes locators and raises Cerberus.InvalidLocatorError on invalid input.

put_from(locator, from_locator)

@spec put_from(t(), t()) :: t()

resolve_role_kind(role)

@spec resolve_role_kind(String.t() | atom()) :: {:ok, resolved_role_kind()} | :error

resolve_role_kind!(role, original)

@spec resolve_role_kind!(String.t() | atom(), term()) :: resolved_role_kind()

resolved_kind(locator)

@spec resolved_kind(t()) :: locator_kind() | resolved_role_kind()

role(role, opts \\ [])

@spec role(String.t() | atom(), Cerberus.Options.role_locator_opts()) :: t()

sigil(value, modifiers)

@spec sigil(
  String.t(),
  charlist()
) :: t()

text_sigil(value)

@spec text_sigil(String.t()) :: t()