robotcode-repl 0.99.0__tar.gz → 0.100.0__tar.gz

{robotcode_repl-0.99.0 → robotcode_repl-0.100.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: robotcode-repl
-Version: 0.99.0
+Version: 0.100.0
 Summary: RobotCode REPL for Robot Framework
 Project-URL: Homepage, https://robotcode.io
 Project-URL: Donate, https://opencollective.com/robotcode
@@ -24,8 +24,7 @@ Classifier: Programming Language :: Python :: Implementation :: PyPy
 Classifier: Topic :: Utilities
 Classifier: Typing :: Typed
 Requires-Python: >=3.8
-Requires-Dist: robotcode-jsonrpc2==0.99.0
-Requires-Dist: robotcode-runner==0.99.0
+Requires-Dist: robotcode-runner==0.100.0
 Description-Content-Type: text/markdown
 
 # robotcode-repl
@@ -38,7 +37,8 @@ Description-Content-Type: text/markdown
 
 ## Introduction
 
-Some classes for [RobotCode](https://robotcode.io) plugin management
+Provides a REPL for [RobotCode](https://robotcode.io).
+
 
 ## Installation
 

{robotcode_repl-0.99.0 → robotcode_repl-0.100.0}/README.md

@@ -8,7 +8,8 @@
 
 ## Introduction
 
-Some classes for [RobotCode](https://robotcode.io) plugin management
+Provides a REPL for [RobotCode](https://robotcode.io).
+
 
 ## Installation
 

{robotcode_repl-0.99.0 → robotcode_repl-0.100.0}/pyproject.toml

@@ -27,8 +27,7 @@ classifiers = [
 ]
 dynamic = ["version"]
 dependencies = [
-  "robotcode-jsonrpc2==0.99.0",
-  "robotcode-runner==0.99.0"
+  "robotcode-runner==0.100.0"
 ]
 
 [project.entry-points.robotcode]

robotcode_repl-0.100.0/src/robotcode/repl/__version__.py

@@ -0,0 +1 @@
+__version__ = "0.100.0"

robotcode_repl-0.99.0/src/robotcode/repl/interpreter.py → robotcode_repl-0.100.0/src/robotcode/repl/base_interpreter.py

@@ -1,8 +1,8 @@
-import sys
+import abc
+from datetime import datetime
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Iterator, List, Optional, Tuple, Union, cast
 
-import click
 from robot.api import get_model
 from robot.errors import ExecutionStatus
 from robot.output import LOGGER
@@ -11,7 +11,7 @@ from robot.running import Keyword, TestCase, TestSuite
 from robot.running.context import EXECUTION_CONTEXTS
 from robot.running.signalhandler import _StopSignalMonitor
 
-from robotcode.plugin import Application
+from robotcode.core.utils.path import normalized_path
 from robotcode.robot.utils import get_robot_version
 from robotcode.robot.utils.ast import iter_nodes
 
@@ -46,26 +46,21 @@ else:
         return kw.run(context)
 
 
-TRUE_STRINGS = {"TRUE", "YES", "ON", "1"}
-
-
-def is_true(value: Union[str, bool]) -> bool:
-    if isinstance(value, str):
-        return value.upper() in TRUE_STRINGS
-    return bool(value)
-
-
 if get_robot_version() < (7, 0):
 
     class InterpreterLogger:
-        def __init__(self, interpreter: "Interpreter") -> None:
+        def __init__(self, interpreter: "BaseInterpreter") -> None:
             self.interpreter = interpreter
             self.enabled = False
 
         def log_message(self, message: OutputMessage) -> None:
+            if not self.enabled:
+                return
             self.interpreter.log_message(message.message, message.level, message.html, message.timestamp)
 
         def message(self, message: OutputMessage) -> None:
+            if not self.enabled:
+                return
             self.interpreter.message(message.message, message.level, message.html, message.timestamp)
 
         def start_keyword(self, args: Any) -> None:
@@ -82,14 +77,18 @@ else:
     import robot.output.loggerapi  # pyright: ignore[reportMissingImports]
 
     class InterpreterLogger(robot.output.loggerapi.LoggerApi):  # type: ignore[no-redef]
-        def __init__(self, interpreter: "Interpreter") -> None:
+        def __init__(self, interpreter: "BaseInterpreter") -> None:
             self.interpreter = interpreter
             self.enabled = False
 
         def log_message(self, message: OutputMessage) -> None:
+            if not self.enabled:
+                return
             self.interpreter.log_message(message.message, message.level, message.html, message.timestamp)
 
         def message(self, message: OutputMessage) -> None:
+            if not self.enabled:
+                return
             self.interpreter.message(message.message, message.level, message.html, message.timestamp)
 
         def start_keyword(self, data: "running.Keyword", result: "result.Keyword") -> None:
@@ -102,28 +101,26 @@ else:
                 return
             self.interpreter.end_keyword(data, result)
 
+        def start_body_item(self, data: "running.Keyword", result: "result.Keyword") -> None:
+            if not self.enabled:
+                return
+            self.interpreter.start_keyword(data, result)
 
-class Interpreter:
-    def __init__(
-        self,
-        app: Optional[Application],
-        files: Optional[List[Path]] = None,
-        show_keywords: bool = False,
-        inspect: Optional[bool] = False,
-    ) -> None:
-        _patch()
+        def end_body_item(self, data: "running.Keyword", result: "result.Keyword") -> None:
+            if not self.enabled:
+                return
+            self.interpreter.end_keyword(data, result)
 
-        self.app = app
-        self.files = files
-        self.show_keywords = show_keywords
-        self.inspect = inspect
 
-        self.executed_files: List[Path] = []
+class BaseInterpreter(abc.ABC):
+    def __init__(self) -> None:
+        _patch()
 
         self._logger = InterpreterLogger(self)
         LOGGER.register_logger(self._logger)
-
+        self.last_result: Any = None
         self.indent = 0
+        self.source: Optional[Path] = None
 
     def check_for_errors(self, node: Any) -> List[str]:
         if hasattr(node, "tokens"):
@@ -145,7 +142,9 @@ class Interpreter:
             + ("\n  ".join(command.split("\n")) if "\n" in command else command)
         ) + "\n"
 
-        model = get_model(suite_str)
+        curdir = normalized_path(self.source).parent if self.source is not None else Path.cwd()
+
+        model = get_model(suite_str, curdir=str(curdir).replace("\\", "\\\\"))
         suite: TestSuite = TestSuite.from_model(model)
 
         errors: List[str] = []
@@ -155,80 +154,39 @@ class Interpreter:
 
         return cast(TestCase, suite.tests[0]), errors
 
-    def get_input(self) -> Iterator[Optional[Keyword]]:
-        if self.executed_files and not self.files and not self.inspect:
-            raise EOFError
-
-        if self.files:
-            file = self.files.pop(0)
-
-            self.executed_files.append(file)
-
-            text = file.read_text(encoding="utf-8")
-
-            test, errors = self.get_test_body_from_string(text)
-            if errors:
-                return
-
-            for kw in test.body:
-                yield kw
-        else:
-
-            lines: List[str] = []
-            last_one = False
-            while True:
-
-                prompt = ""
-                if sys.stdin.isatty():
-                    prompt = ">>> " if not lines else "... "
-
-                try:
-                    text = input(prompt)
-                    if len(lines) == 0 and text == "":
-                        break
-                except KeyboardInterrupt:
-                    if len(lines) > 0:
-                        lines = []
-                        last_one = False
-                        continue
-                    raise
-
-                lines.append(text)
-
-                test, errors = self.get_test_body_from_string("\n".join(lines))
-
-                if len(lines) > 1 and lines[-1] == "" and text == "":
-                    last_one = True
-
-                if errors:
-                    if not last_one:
-                        continue
-
-                for kw in test.body:
-                    yield kw
-
-                break
+    @abc.abstractmethod
+    def get_input(self) -> Iterator[Optional[Keyword]]: ...
 
     def run_keyword(self, kw: Keyword) -> Any:
         self.indent = 0
         context = EXECUTION_CONTEXTS.current
-        return _run_keyword(kw, context)
+        try:
+            return _run_keyword(kw, context)
+        except (SystemExit, KeyboardInterrupt):
+            raise
+        except ExecutionStatus:
+            raise
+        except BaseException as e:
+            self.log_message(str(e), "ERROR", timestamp=datetime.now())  # noqa: DTZ005
 
     def run(self) -> Any:
         self._logger.enabled = True
 
         has_input = True
-        while has_input:
-            try:
-                self.run_input()
-            except EOFError:
-                break
-            except (SystemExit, KeyboardInterrupt):
-                break
-            except ExecutionStatus:
-                pass
-            except BaseException as e:
-                self.log_message(str(e), "ERROR")
+        try:
+            while has_input:
+                try:
+                    self.run_input()
+                except EOFError:
+                    break
+                except (SystemExit, KeyboardInterrupt):
+                    break
+                except ExecutionStatus:
+                    pass
+                except BaseException as e:
+                    self.log_message(str(e), "ERROR", timestamp=datetime.now())  # noqa: DTZ005
+        finally:
+            self._logger.enabled = False
 
     def run_input(self) -> None:
         for kw in self.get_input():
@@ -237,65 +195,29 @@ class Interpreter:
             self.set_last_result(self.run_keyword(kw))
 
     def set_last_result(self, result: Any) -> None:
-        if result is None:
-            return
-        if self.app is not None:
-            self.app.echo(f"{result}")
+        self.last_result = result
 
+    @abc.abstractmethod
     def log_message(
-        self, message: str, level: str, html: Union[str, bool] = False, timestamp: Optional[str] = None
-    ) -> None:
-        if self.app is None:
-            return
-
-        if not self.app.config.verbose and level in ["DEBUG", "TRACE"]:
-            return
-
-        std_err = level in ["ERROR", "FAIL"]
-
-        if level == "INFO":
-            level = click.style("INFO", fg="green")
-        elif level == "WARN":
-            level = click.style("WARN", fg="yellow")
-        elif level == "ERROR":
-            level = click.style("ERROR", fg="red")
-        elif level == "FAIL":
-            level = click.style("FAIL", fg="red", bold=True)
-        elif level == "SKIP":
-            level = click.style("SKIP", dim=True)
-        elif level == "DEBUG":
-            level = click.style("DEBUG", fg="bright_black")
-        elif level == "TRACE":
-            level = click.style("TRACE", fg="bright_black", dim=True)
-
-        if is_true(html):
-            message = f"*HTML*{message}"
-
-        self.app.echo(f"{'  '*self.indent}[ {level} ] {message}", file=sys.__stdout__ if std_err else sys.__stderr__)
+        self, message: str, level: str, html: Union[str, bool] = False, timestamp: Union[datetime, str, None] = None
+    ) -> None: ...
 
+    @abc.abstractmethod
     def message(
-        self, message: str, level: str, html: Union[str, bool] = False, timestamp: Optional[str] = None
-    ) -> None:
-        if self.app is not None and self.app.config.verbose:
-            self.log_message(message, level, html, timestamp)
+        self, message: str, level: str, html: Union[str, bool] = False, timestamp: Union[datetime, str, None] = None
+    ) -> None: ...
 
     def start_keyword(self, data: "running.Keyword", result: "result.Keyword") -> None:
-        if not self.show_keywords:
-            return
+        pass
 
-        if self.app is None:
-            return
+    def end_keyword(self, data: "running.Keyword", result: "result.Keyword") -> None:
+        pass
 
-        self.app.echo(
-            f"{'  '*self.indent}KEYWORD {result.libname}.{result.kwname}  {'  '.join(result.args)}", file=sys.__stdout__
-        )
-        self.indent += 1
 
-    def end_keyword(self, data: "running.Keyword", result: "result.Keyword") -> None:
-        if not self.show_keywords:
-            return
+TRUE_STRINGS = {"TRUE", "YES", "ON", "1"}
 
-        if self.app is None:
-            return
 
-        self.indent -= 1
+def is_true(value: Union[str, bool]) -> bool:
+    if isinstance(value, str):
+        return value.upper() in TRUE_STRINGS
+    return bool(value)

robotcode_repl-0.100.0/src/robotcode/repl/cli.py

@@ -0,0 +1,141 @@
+from pathlib import Path
+from typing import Optional, Tuple
+
+import click
+
+from robotcode.plugin import Application, pass_application
+
+from .__version__ import __version__
+from .console_interpreter import ConsoleInterpreter
+from .run import run_repl
+
+
+@click.command(add_help_option=True)
+@click.option(
+    "-v",
+    "--variable",
+    metavar="name:value",
+    type=str,
+    multiple=True,
+    help="Set variables in the test data. see `robot --variable` option.",
+)
+@click.option(
+    "-V",
+    "--variablefile",
+    metavar="PATH",
+    type=str,
+    multiple=True,
+    help="Python or YAML file file to read variables from. see `robot --variablefile` option.",
+)
+@click.option(
+    "-P",
+    "--pythonpath",
+    metavar="PATH",
+    type=str,
+    multiple=True,
+    help="Additional locations where to search test libraries"
+    " and other extensions when they are imported. see `robot --pythonpath` option.",
+)
+@click.option(
+    "-k",
+    "--show-keywords",
+    is_flag=True,
+    default=False,
+    help="Executed keywords will be shown in the output.",
+)
+@click.option(
+    "-i",
+    "--inspect",
+    is_flag=True,
+    default=False,
+    help="Activate inspection mode. This forces a prompt to appear after the REPL script is executed.",
+)
+@click.option(
+    "-d",
+    "--outputdir",
+    metavar="DIR",
+    type=str,
+    help="Where to create output files. see `robot --outputdir` option.",
+)
+@click.option(
+    "-o",
+    "--output",
+    metavar="FILE",
+    type=str,
+    help="XML output file. see `robot --output` option.",
+)
+@click.option(
+    "-r",
+    "--report",
+    metavar="FILE",
+    type=str,
+    help="HTML output file. see `robot --report` option.",
+)
+@click.option(
+    "-l",
+    "--log",
+    metavar="FILE",
+    type=str,
+    help="HTML log file. see `robot --log` option.",
+)
+@click.option(
+    "-x",
+    "--xunit",
+    metavar="FILE",
+    type=str,
+    help="xUnit output file. see `robot --xunit` option.",
+)
+@click.option(
+    "-s",
+    "--source",
+    type=click.Path(path_type=Path),
+    metavar="FILE",
+    help="Specifies the path to a source file. This file must not exist and will neither be read nor written. "
+    "It is used solely to set the current working directory for the REPL script "
+    "and to assign a name to the internal suite.",
+)
+@click.version_option(version=__version__, prog_name="RobotCode REPL")
+@click.argument(
+    "files",
+    type=click.Path(exists=True, dir_okay=False, path_type=Path),
+    nargs=-1,
+    required=False,
+)
+@pass_application
+def repl(
+    app: Application,
+    variable: Tuple[str, ...],
+    variablefile: Tuple[str, ...],
+    pythonpath: Tuple[str, ...],
+    show_keywords: bool,
+    inspect: bool,
+    outputdir: Optional[str],
+    output: Optional[str],
+    report: Optional[str],
+    log: Optional[str],
+    xunit: Optional[str],
+    source: Optional[Path],
+    files: Tuple[Path, ...],
+) -> None:
+    """\
+    Run Robot Framework interactively.
+    """
+    if files:
+        files = tuple(f.absolute() for f in files)
+
+    interpreter = ConsoleInterpreter(app, files=list(files), show_keywords=show_keywords, inspect=inspect)
+
+    run_repl(
+        interpreter=interpreter,
+        app=app,
+        variablefile=variable,
+        variable=variablefile,
+        pythonpath=pythonpath,
+        outputdir=outputdir,
+        output=output,
+        report=report,
+        log=log,
+        xunit=xunit,
+        source=source,
+        files=files,
+    )

robotcode_repl-0.100.0/src/robotcode/repl/console_interpreter.py

@@ -0,0 +1,140 @@
+import sys
+from datetime import datetime
+from pathlib import Path
+from typing import Iterator, List, Optional, Union
+
+import click
+from robot import result, running
+from robot.running import Keyword
+
+from robotcode.plugin import Application
+
+from .base_interpreter import BaseInterpreter, is_true
+
+
+class ConsoleInterpreter(BaseInterpreter):
+    def __init__(
+        self,
+        app: Optional[Application],
+        files: Optional[List[Path]] = None,
+        show_keywords: bool = False,
+        inspect: Optional[bool] = False,
+    ) -> None:
+        super().__init__()
+
+        self.app = app
+        self.files = files
+        self.show_keywords = show_keywords
+        self.inspect = inspect
+
+        self.executed_files: List[Path] = []
+
+    def get_input(self) -> Iterator[Optional[Keyword]]:
+        if self.executed_files and not self.files and not self.inspect:
+            raise EOFError
+
+        if self.files:
+            file = self.files.pop(0)
+
+            self.executed_files.append(file)
+
+            text = file.read_text(encoding="utf-8")
+
+            test, errors = self.get_test_body_from_string(text)
+            if errors:
+                return
+
+            for kw in test.body:
+                yield kw
+        else:
+            lines: List[str] = []
+            last_one = False
+            while True:
+                prompt = ""
+                if sys.stdin.isatty():
+                    prompt = ">>> " if not lines else "... "
+
+                try:
+                    text = input(prompt)
+                    if len(lines) == 0 and text == "":
+                        break
+                except KeyboardInterrupt:
+                    if len(lines) > 0:
+                        lines = []
+                        last_one = False
+                        continue
+                    raise
+
+                lines.append(text)
+
+                test, errors = self.get_test_body_from_string("\n".join(lines))
+
+                if len(lines) > 1 and lines[-1] == "" and text == "":
+                    last_one = True
+
+                if errors:
+                    if not last_one:
+                        continue
+
+                for kw in test.body:
+                    yield kw
+
+                break
+
+    def log_message(
+        self, message: str, level: str, html: Union[str, bool] = False, timestamp: Union[datetime, str, None] = None
+    ) -> None:
+        if self.app is None:
+            return
+
+        if not self.app.config.verbose and level in ["DEBUG", "TRACE"]:
+            return
+
+        std_err = level in ["ERROR", "FAIL"]
+
+        if level == "INFO":
+            level = click.style("INFO", fg="green")
+        elif level == "WARN":
+            level = click.style("WARN", fg="yellow")
+        elif level == "ERROR":
+            level = click.style("ERROR", fg="red")
+        elif level == "FAIL":
+            level = click.style("FAIL", fg="red", bold=True)
+        elif level == "SKIP":
+            level = click.style("SKIP", dim=True)
+        elif level == "DEBUG":
+            level = click.style("DEBUG", fg="bright_black")
+        elif level == "TRACE":
+            level = click.style("TRACE", fg="bright_black", dim=True)
+
+        if is_true(html):
+            message = f"*HTML*{message}"
+
+        self.app.echo(f"{'  '*self.indent}[ {level} ] {message}", file=sys.__stdout__ if std_err else sys.__stderr__)
+
+    def message(
+        self, message: str, level: str, html: Union[str, bool] = False, timestamp: Union[datetime, str, None] = None
+    ) -> None:
+        if self.app is not None and self.app.config.verbose:
+            self.log_message(message, level, html, timestamp)
+
+    def start_keyword(self, data: "running.Keyword", result: "result.Keyword") -> None:
+        if not self.show_keywords:
+            return
+
+        if self.app is None:
+            return
+
+        self.app.echo(
+            f"{'  '*self.indent}KEYWORD {result.libname}.{result.kwname}  {'  '.join(result.args)}", file=sys.__stdout__
+        )
+        self.indent += 1
+
+    def end_keyword(self, data: "running.Keyword", result: "result.Keyword") -> None:
+        if not self.show_keywords:
+            return
+
+        if self.app is None:
+            return
+
+        self.indent -= 1

robotcode_repl-0.100.0/src/robotcode/repl/run.py

@@ -0,0 +1,133 @@
+import io
+import sys
+from pathlib import Path
+from typing import Any, ClassVar, Dict, Optional, Tuple
+
+from robot.api import TestSuite, get_model
+from robot.conf import RobotSettings
+from robot.errors import DATA_ERROR, INFO_PRINTED, DataError, Information
+from robot.output import LOGGER
+from robot.reporting import ResultWriter
+
+from robotcode.core.utils.path import normalized_path
+from robotcode.plugin import (
+    Application,
+)
+from robotcode.robot.utils import get_robot_version
+from robotcode.runner.cli.robot import RobotFrameworkEx, handle_robot_options
+
+from .base_interpreter import BaseInterpreter
+
+REPL_SUITE = """\
+*** Settings ***
+Library  robotcode.repl.Repl
+*** Test Cases ***
+RobotCode REPL
+    repl
+"""
+
+
+class ReplListener:
+    ROBOT_LISTENER_API_VERSION = 2
+    instance: ClassVar["ReplListener"]
+
+    def __init__(self, app: Application, interpreter: BaseInterpreter) -> None:
+        ReplListener.instance = self
+        self.app = app
+        self.interpreter = interpreter
+
+    def start_keyword(
+        self,
+        name: str,
+        attributes: Dict[str, Any],
+    ) -> None:
+        if name != "robotcode.repl.Repl.Repl":
+            return
+
+        self.interpreter.run()
+
+
+def run_repl(
+    interpreter: BaseInterpreter,
+    app: Application,
+    variable: Tuple[str, ...] = (),
+    variablefile: Tuple[str, ...] = (),
+    pythonpath: Tuple[str, ...] = (),
+    outputdir: Optional[str] = None,
+    output: Optional[str] = None,
+    report: Optional[str] = None,
+    log: Optional[str] = None,
+    xunit: Optional[str] = None,
+    source: Optional[Path] = None,
+    files: Tuple[Path, ...] = (),
+) -> None:
+    robot_options_and_args: Tuple[str, ...] = ()
+
+    if files:
+        files = tuple(f.absolute() for f in files)
+
+    for var in variable:
+        robot_options_and_args += ("--variable", var)
+    for varfile in variablefile:
+        robot_options_and_args += ("--variablefile", varfile)
+    for pypath in pythonpath:
+        robot_options_and_args += ("--pythonpath", pypath)
+    if outputdir:
+        robot_options_and_args += ("--outputdir", outputdir)
+
+    root_folder, _profile, cmd_options = handle_robot_options(app, (*robot_options_and_args, *(str(f) for f in files)))
+
+    with app.chdir(root_folder) as orig_folder:
+        try:
+            curdir = normalized_path(source).parent if source is not None else Path.cwd()
+
+            options, _ = RobotFrameworkEx(
+                app,
+                ["."],
+                app.config.dry,
+                root_folder=root_folder,
+                orig_folder=orig_folder,
+            ).parse_arguments((*cmd_options, *robot_options_and_args))
+
+            interpreter.source = source
+
+            settings = RobotSettings(
+                options,
+                outputdir=str(curdir),
+                console="NONE",
+                output=output,
+                log=log,
+                report=report,
+                xunit=xunit,
+                quiet=True,
+                listener=[
+                    ReplListener(app, interpreter),
+                ],
+            )
+
+            if app is not None and app.show_diagnostics:
+                LOGGER.register_console_logger(**settings.console_output_config)
+            else:
+                LOGGER.unregister_console_logger()
+
+            if get_robot_version() >= (5, 0):
+                if settings.pythonpath:
+                    sys.path = settings.pythonpath + sys.path
+
+            with io.StringIO(REPL_SUITE) as suite_io:
+                model = get_model(suite_io, curdir=str(curdir).replace("\\", "\\\\"))
+
+                suite = TestSuite.from_model(model)
+                suite.configure(**settings.suite_config)
+                result = suite.run(settings)
+
+                if settings.log or settings.report or settings.xunit:
+                    writer = ResultWriter(settings.output if settings.log else result)
+                    writer.write_results(settings.get_rebot_settings())
+
+        except Information as err:
+            app.echo(str(err))
+            app.exit(INFO_PRINTED)
+        except DataError as err:
+            app.error(str(err))
+            app.exit(DATA_ERROR)

robotcode_repl-0.99.0/src/robotcode/repl/__version__.py

@@ -1 +0,0 @@
-__version__ = "0.99.0"

robotcode_repl-0.99.0/src/robotcode/repl/cli/__init__.py

@@ -1,3 +0,0 @@
-from .repl import repl
-
-__all__ = ["repl"]

robotcode_repl-0.99.0/src/robotcode/repl/cli/repl.py

@@ -1,232 +0,0 @@
-import io
-import sys
-from pathlib import Path
-from typing import Optional, Tuple
-
-import click
-from robot.api import TestSuite, get_model
-from robot.conf import RobotSettings
-from robot.errors import DATA_ERROR, INFO_PRINTED, DataError, Information
-from robot.output import LOGGER
-from robot.reporting import ResultWriter
-
-from robotcode.plugin import (
-    Application,
-    pass_application,
-)
-from robotcode.robot.utils import get_robot_version
-from robotcode.runner.cli.robot import RobotFrameworkEx, handle_robot_options
-
-from ..interpreter import Interpreter
-from ..repl_listener import ReplListener
-
-REPL_SUITE = """\
-*** Settings ***
-Library  robotcode.repl.Repl
-*** Test Cases ***
-RobotCode REPL
-    repl
-"""
-
-
-def run_repl(
-    app: Application,
-    inspect: bool = False,
-    variable: Tuple[str, ...] = (),
-    variablefile: Tuple[str, ...] = (),
-    pythonpath: Tuple[str, ...] = (),
-    outputdir: Optional[str] = None,
-    output: Optional[str] = None,
-    report: Optional[str] = None,
-    log: Optional[str] = None,
-    xunit: Optional[str] = None,
-    files: Tuple[Path, ...] = (),
-    show_keywords: bool = False,
-    interpreter: Optional[Interpreter] = None,
-) -> None:
-    robot_options_and_args: Tuple[str, ...] = ()
-
-    if files:
-        files = tuple(f.absolute() for f in files)
-
-    for var in variable:
-        robot_options_and_args += ("--variable", var)
-    for varfile in variablefile:
-        robot_options_and_args += ("--variablefile", varfile)
-    for pypath in pythonpath:
-        robot_options_and_args += ("--pythonpath", pypath)
-    if outputdir:
-        robot_options_and_args += ("--outputdir", outputdir)
-
-    root_folder, _profile, cmd_options = handle_robot_options(app, (*robot_options_and_args, *(str(f) for f in files)))
-
-    try:
-
-        options, _ = RobotFrameworkEx(
-            app,
-            ["."],
-            app.config.dry,
-            root_folder,
-        ).parse_arguments((*cmd_options, *robot_options_and_args))
-
-        if interpreter is None:
-            interpreter = Interpreter(app, files=list(files), show_keywords=show_keywords, inspect=inspect)
-
-        settings = RobotSettings(
-            options,
-            console="NONE",
-            output=output,
-            log=log,
-            report=report,
-            xunit=xunit,
-            quiet=True,
-            listener=[
-                ReplListener(app, interpreter),
-            ],
-        )
-
-        if app is not None and app.show_diagnostics:
-            LOGGER.register_console_logger(**settings.console_output_config)
-        else:
-            LOGGER.unregister_console_logger()
-
-        if get_robot_version() >= (5, 0):
-            if settings.pythonpath:
-                sys.path = settings.pythonpath + sys.path
-
-        with io.StringIO(REPL_SUITE) as suite_io:
-            model = get_model(suite_io)
-
-            suite = TestSuite.from_model(model)
-            suite.configure(**settings.suite_config)
-            result = suite.run(settings)
-
-            if settings.log or settings.report or settings.xunit:
-                writer = ResultWriter(settings.output if settings.log else result)
-                writer.write_results(settings.get_rebot_settings())
-
-    except Information as err:
-        app.echo(str(err))
-        app.exit(INFO_PRINTED)
-    except DataError as err:
-        app.error(str(err))
-        app.exit(DATA_ERROR)
-
-
-@click.command(
-    context_settings={"allow_extra_args": True, "ignore_unknown_options": True},
-    add_help_option=True,
-)
-@click.option(
-    "-v",
-    "--variable",
-    metavar="name:value",
-    type=str,
-    multiple=True,
-    help="Set variables in the test data. see `robot --variable` option.",
-)
-@click.option(
-    "-V",
-    "--variablefile",
-    metavar="PATH",
-    type=str,
-    multiple=True,
-    help="Python or YAML file file to read variables from. see `robot --variablefile` option.",
-)
-@click.option(
-    "-P",
-    "--pythonpath",
-    metavar="PATH",
-    type=str,
-    multiple=True,
-    help="Additional locations where to search test libraries"
-    " and other extensions when they are imported. see `robot --pythonpath` option.",
-)
-@click.option(
-    "-k",
-    "--show-keywords",
-    is_flag=True,
-    default=False,
-    help="Executed keywords will be shown in the output.",
-)
-@click.option(
-    "-i",
-    "--inspect",
-    is_flag=True,
-    default=False,
-    help="Activate inspection mode. This forces a prompt to appear after the REPL script is executed.",
-)
-@click.option(
-    "-d",
-    "--outputdir",
-    metavar="DIR",
-    type=str,
-    help="Where to create output files. see `robot --outputdir` option.",
-)
-@click.option(
-    "-o",
-    "--output",
-    metavar="FILE",
-    type=str,
-    help="XML output file. see `robot --output` option.",
-)
-@click.option(
-    "-r",
-    "--report",
-    metavar="FILE",
-    type=str,
-    help="HTML output file. see `robot --report` option.",
-)
-@click.option(
-    "-l",
-    "--log",
-    metavar="FILE",
-    type=str,
-    help="HTML log file. see `robot --log` option.",
-)
-@click.option(
-    "-x",
-    "--xunit",
-    metavar="FILE",
-    type=str,
-    help="xUnit output file. see `robot --xunit` option.",
-)
-@click.argument(
-    "files",
-    type=click.Path(exists=True, dir_okay=False, path_type=Path),
-    nargs=-1,
-    required=False,
-)
-@pass_application
-def repl(
-    app: Application,
-    variable: Tuple[str, ...],
-    variablefile: Tuple[str, ...],
-    pythonpath: Tuple[str, ...],
-    show_keywords: bool,
-    inspect: bool,
-    outputdir: Optional[str],
-    output: Optional[str],
-    report: Optional[str],
-    log: Optional[str],
-    xunit: Optional[str],
-    files: Tuple[Path, ...],
-) -> None:
-    """\
-    Run Robot Framework interactively.
-    """
-
-    run_repl(
-        app=app,
-        inspect=inspect,
-        variablefile=variable,
-        variable=variablefile,
-        pythonpath=pythonpath,
-        outputdir=outputdir,
-        output=output,
-        report=report,
-        log=log,
-        xunit=xunit,
-        files=files,
-        show_keywords=show_keywords,
-    )

robotcode_repl-0.99.0/src/robotcode/repl/repl_listener.py

@@ -1,25 +0,0 @@
-from typing import Any, ClassVar, Dict, Optional
-
-from robotcode.plugin import Application
-
-from .interpreter import Interpreter
-
-
-class ReplListener:
-    ROBOT_LISTENER_API_VERSION = 2
-    instance: ClassVar["ReplListener"]
-
-    def __init__(self, app: Application, interpreter: Optional[Interpreter] = None) -> None:
-        ReplListener.instance = self
-        self.app = app
-        self.interpreter = interpreter or Interpreter(app)
-
-    def start_keyword(
-        self,
-        name: str,
-        attributes: Dict[str, Any],
-    ) -> None:
-        if name != "robotcode.repl.Repl.Repl":
-            return
-
-        self.interpreter.run()