# Copyright 2008-2015 Nokia Networks
# Copyright 2016- Robot Framework Foundation
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import re
from abc import ABC
from inspect import signature
from pathlib import Path
from typing import Callable
from robot.conf import LanguagesLike
from robot.errors import DataError
from robot.parsing import File, get_init_model, get_model, get_resource_model
from robot.parsing.model import ModelVisitor, Statement
from robot.utils import FileReader, get_error_message, type_name
from ..model import TestSuite
from ..resourcemodel import ResourceFile
from .settings import FileSettings, InitFileSettings, TestDefaults
from .transformers import ResourceBuilder, SuiteBuilder
[docs]
class Parser(ABC):
@property
def name(self) -> str:
return type(self).__name__
[docs]
def parse_suite_file(self, source: Path, defaults: TestDefaults) -> TestSuite:
raise DataError(f"'{self.name}' does not support parsing suite files.")
[docs]
def parse_init_file(self, source: Path, defaults: TestDefaults) -> TestSuite:
raise DataError(f"'{self.name}' does not support parsing initialization files.")
[docs]
def parse_resource_file(self, source: Path) -> ResourceFile:
raise DataError(f"'{self.name}' does not support parsing resource files.")
[docs]
class RobotParser(Parser):
extensions = ()
def __init__(self, lang: LanguagesLike = None, process_curdir: bool = True):
self.lang = lang
self.process_curdir = process_curdir
[docs]
def parse_suite_file(self, source: Path, defaults: TestDefaults) -> TestSuite:
model = self._get_model(get_model, source)
return self.parse_model(model, defaults)
[docs]
def parse_init_file(self, source: Path, defaults: TestDefaults) -> TestSuite:
model = self._get_model(get_init_model, source)
suite = TestSuite(
name=TestSuite.name_from_source(source.parent),
source=source.parent,
rpa=None,
)
SuiteBuilder(suite, InitFileSettings(defaults)).build(model)
return suite
[docs]
def parse_model(
self,
model: File,
defaults: "TestDefaults | None" = None,
) -> TestSuite:
name = TestSuite.name_from_source(model.source, self.extensions)
suite = TestSuite(name=name, source=model.source)
SuiteBuilder(suite, FileSettings(defaults)).build(model)
return suite
def _get_model(self, model_getter: Callable[..., File], source: Path) -> File:
model = model_getter(
self._get_source(source),
data_only=True,
curdir=self._get_curdir(source),
lang=self.lang,
)
model.source = source
return model
def _get_curdir(self, source: Path) -> "str | None":
return str(source.parent).replace("\\", "\\\\") if self.process_curdir else None
def _get_source(self, source: Path) -> "Path | str":
return source
[docs]
def parse_resource_file(self, source: Path) -> ResourceFile:
model = self._get_model(get_resource_model, source)
return self.parse_resource_model(model)
[docs]
def parse_resource_model(self, model: File) -> ResourceFile:
resource = ResourceFile(source=model.source)
ResourceBuilder(resource).build(model)
return resource
[docs]
class RestParser(RobotParser):
extensions = (".robot.rst", ".rst", ".rest")
def _get_source(self, source: Path) -> str:
from .restreader import read_rest_data
with FileReader(source) as reader:
return read_rest_data(reader)
[docs]
class MarkdownParser(RobotParser):
extensions = (".robot.md", ".md", ".markdown")
def _get_model(self, model_getter: Callable[..., File], source: Path) -> File:
with FileReader(source) as reader:
data, offsets = self._read_markdown_data(reader)
model = model_getter(
data,
data_only=True,
curdir=self._get_curdir(source),
lang=self.lang,
)
model.source = source
if offsets:
ColumnOffsetUpdater(offsets).visit(model)
return model
def _read_markdown_data(self, mdfile: FileReader) -> "tuple[str, dict[int, int]]":
fence_open = re.compile(r"(\s*)(`{3,}|~{3,})\s*(\S+)")
fence_close = None
fence_indent = 0
data = []
offsets = {}
for lineno, line in enumerate(mdfile.readlines(), start=1):
if fence_close is None:
# Lines outside code blocks are replaced with empty lines to
# preserve line numbers.
data.append("\n")
match = fence_open.match(line)
if match:
indent, fence, lang = match.groups()
if lang.lower() in ("robotframework", "robot"):
fence_close = re.compile(rf"\s*{fence[0]}{{{len(fence)},}}\s*")
fence_indent = len(indent)
elif fence_close.fullmatch(line):
data.append("\n")
fence_close = None
elif line.strip():
offset = min(len(line) - len(line.lstrip()), fence_indent)
data.append(line[offset:])
if offset:
offsets[lineno] = offset
else:
data.append(line)
return "".join(data), offsets
[docs]
class ColumnOffsetUpdater(ModelVisitor):
def __init__(self, offsets: "dict[int, int]"):
self.offsets = offsets
[docs]
def visit_Statement(self, node: Statement):
for token in node.tokens:
token.col_offset += self.offsets.get(token.lineno, 0)
[docs]
class JsonParser(Parser):
[docs]
def parse_suite_file(self, source: Path, defaults: TestDefaults) -> TestSuite:
return TestSuite.from_json(source)
[docs]
def parse_init_file(self, source: Path, defaults: TestDefaults) -> TestSuite:
return TestSuite.from_json(source)
[docs]
def parse_resource_file(self, source: Path) -> ResourceFile:
try:
return ResourceFile.from_json(source)
except DataError as err:
raise DataError(f"Parsing JSON resource file '{source}' failed: {err}")
[docs]
class NoInitFileDirectoryParser(Parser):
[docs]
def parse_init_file(self, source: Path, defaults: TestDefaults) -> TestSuite:
return TestSuite(
name=TestSuite.name_from_source(source),
source=source,
rpa=None,
)
[docs]
class CustomParser(Parser):
def __init__(self, parser):
self.parser = parser
if not getattr(parser, "parse", None):
raise TypeError(f"'{self.name}' does not have mandatory 'parse' method.")
if not self.extensions:
raise TypeError(
f"'{self.name}' does not have mandatory 'EXTENSION' or 'extension' "
f"attribute."
)
@property
def name(self) -> str:
return type_name(self.parser)
@property
def extensions(self) -> "tuple[str, ...]":
ext = (
getattr(self.parser, "EXTENSION", None)
or getattr(self.parser, "extension", None)
) # fmt: skip
extensions = [ext] if isinstance(ext, str) else list(ext or ())
return tuple(ext.lower().lstrip(".") for ext in extensions)
[docs]
def parse_suite_file(self, source: Path, defaults: TestDefaults) -> TestSuite:
return self._parse(self.parser.parse, source, defaults)
[docs]
def parse_init_file(self, source: Path, defaults: TestDefaults) -> TestSuite:
parse_init = getattr(self.parser, "parse_init", None)
try:
return self._parse(parse_init, source, defaults, init=True)
except NotImplementedError:
return super().parse_init_file(source, defaults) # Raises DataError
def _parse(self, method, source, defaults, init=False) -> TestSuite:
if not method:
raise NotImplementedError
accepts_defaults = len(signature(method).parameters) == 2
try:
suite = method(source, defaults) if accepts_defaults else method(source)
if not isinstance(suite, TestSuite):
raise TypeError(
f"Return value should be 'robot.running.TestSuite', got "
f"'{type_name(suite)}'."
)
except Exception:
method_name = "parse" if not init else "parse_init"
raise DataError(
f"Calling '{self.name}.{method_name}()' failed: {get_error_message()}"
)
return suite