Project settings (#2985)

* Initial creation of settings if .robot directory exists in project dir.

* Correct settings to edit, ut always starts with wrong. Ignore command line arguments

* Still does not update preferences colors. Needs to reload Text Editor and Test Runner

* Improve settings change in Tree when changed project. TODO reload plugins

* Fix opening last file, independent of project settings

* Initial dialog to restart RIDE, when project settings detected

* Working Reload on project settings. Missing restore on not project, fix exceptions.

* Complete project settings detection and restore

* Implenent project settings in Windows

* Initial utest for Project Settings.

Author: HelioGuilherme66

CHANGELOG.adoc

@@ -8,6 +8,9 @@ and this project adheres to http://semver.org/spec/v2.0.0.html[Semantic Versioni
 
 == https://github.com/robotframework/RIDE[Unreleased]
 
+=== Added
+- Added Project Settings concept. The Project Settings is a  file named ``ride_settings.cfg`` inside a directory named ``.robot`` located in the Test Suite directory. The search for this directory, is done upwards from the Test Suite directory. You can create an empty directory, ``.robot`` located in the Test Suite directory or any parent directory, and RIDE will create and use the ``ride_settings.cfg``. This way you can have different settings, like: colors, UI language, and Plugins settings. The most relevant example is the creation of different Run Profiles or Arguments, in Test Runner. When you open a Test Suite outside one with Project Settings, you will see a dialog to restart RIDE, to use the ``Global Settings``.
+
 === Fixed
 - Fixed crash when renaming test cases names on Tree (Project Explorer), by cancelling with Escape or by adding a Space in the end.
 - Fixed  missing text colorization in suites and test settings on Grid Editor.

README.adoc

@@ -44,7 +44,7 @@ Likewise, the current version of wxPython, is 4.2.3, but RIDE is known to work w
 
 `pip install -U robotframework-ride`
 
-(3.8 <= python <= 3.14) Install current development version (**2.2dev41**) with:
+(3.8 <= python <= 3.14) Install current development version (**2.2dev42**) with:
 
 `pip install -U https://github.com/robotframework/RIDE/archive/develop.zip`
 

src/robotide/__init__.py

@@ -66,6 +66,7 @@ def main(*args):
         print(version.VERSION)
         sys.exit(0)
     noupdatecheck, debug_console, settings_path, inpath = _parse_args(args)
+    # print(f"DEBUG: robotide/__init__.py main inpath={inpath}\n")
     if len(args) > 3 or '--help' in args:
         print(__doc__)
         sys.exit()

src/robotide/application/CHANGELOG.html

@@ -15,14 +15,17 @@
 
 import builtins
 import os
+import psutil
 import subprocess
+import sys
 
 import wx
 
 from contextlib import contextmanager
 from pathlib import Path
 
 from ..namespace import Namespace
+from ..context import SETTINGS_DIRECTORY
 from ..controller import Project
 from ..spec import librarydatabase
 from ..ui import LoadProgressObserver
@@ -58,6 +61,33 @@
 FOREGROUND_TEXT = 'foreground text'
 FONT_SIZE = 'font size'
 FONT_FACE = 'font face'
+SPC = "  "
+FIVE_SPC = SPC*5
+NORMAL_SETTINGS = _('Global Settings')
+NORMAL_SETTINGS_DETECTED = _('Global Settings Detected')
+PROJECT_SETTINGS = _('Project Settings')
+PROJECT_SETTINGS_DETECTED = _('Project Settings Detected')
+
+
+def restart_RIDE(args:list):
+    script = os.path.abspath(os.path.dirname(__file__) + '/../__init__.py')  # This is probably a different signature
+    python = sys.executable
+    arguments = [python, script]
+    for a in args:
+        if a:
+            arguments.append(a)
+    # print(f"DEBUG: Application.py restart_RIDE arguments={arguments}\n")
+    """
+    try:
+        process = psutil.Process(os.getpid())
+        # process.terminate()
+        for handler in process.open_files() + process.connections():
+            os.close(handler.fd)
+    except Exception as e:
+        pass
+    """
+    str_args = " ".join(arguments)
+    subprocess.Popen(str_args, shell=True)
 
 
 class UnthemableWidgetError(Exception):
@@ -84,8 +114,10 @@ def __init__(self, path=None, updatecheck=True, settingspath=None):
         self._updatecheck = updatecheck
         self.workspace_path = path
         self.changed_workspace = False
+        self.preferences = None
         self.settings_path = settingspath
         context.APP = self
+        # print(f"DEBUG: Application.py RIDE __init__ path={self.workspace_path}\n")
         wx.App.__init__(self, redirect=False)
 
     def OnInit(self):  # Overrides wx method
@@ -94,6 +126,16 @@ def OnInit(self):  # Overrides wx method
         self._locale = wx.Locale(wx.LANGUAGE_ENGLISH_US)  # LANGUAGE_PORTUGUESE
         # Needed for SetToolTipString to work
         wx.HelpProvider.Set(wx.SimpleHelpProvider())  # DEBUG: adjust to wx versions
+        # Use Project settings if available
+        from ..recentfiles import RecentFilesPlugin
+        self.settings = RideSettings(self.settings_path)  # We need this to know the available plugins
+        self._plugin_loader = PluginLoader(self, self._get_plugin_dirs(), [RecentFilesPlugin],
+                                           silent=True)
+            # print(f"DEBUG: Application.py RIDE OnInit path={self.workspace_path}\n")
+        self.workspace_path = self.workspace_path or self._get_latest_path()
+        # print(f"DEBUG: Application.py RIDE OnInit AFTER _get_latest_path() path={self.workspace_path}")
+        if not self.settings_path:
+            self.settings_path = self.initialize_project_settings(self.workspace_path)
         self.settings = RideSettings(self.settings_path)
 
         class Message:
@@ -105,7 +147,8 @@ class Message:
         from ..context import coreplugins, SETTINGS_DIRECTORY
         from ..ui.treeplugin import TreePlugin
         librarydatabase.initialize_database()
-        self.preferences = Preferences(self.settings)
+        # self.preferences = Preferences(self.settings, self.settings_path)
+        self.reload_preferences(Message)
         self.namespace = Namespace(self.settings)
         self._controller = Project(self.namespace, self.settings)
         # Try to get FontInfo as soon as possible
@@ -115,8 +158,7 @@ class Message:
         self.frame = RideFrame(self, self._controller)
         # DEBUG  self.frame.Show()
         self._editor_provider = EditorProvider()
-        self._plugin_loader = PluginLoader(self, self._get_plugin_dirs(),
-                                           coreplugins.get_core_plugins())
+        self._plugin_loader = PluginLoader(self, self._get_plugin_dirs(), coreplugins.get_core_plugins())
         self._plugin_loader.enable_plugins()
         perspective = self.settings.get('AUI Perspective', None)
         if perspective:
@@ -128,7 +170,7 @@ class Message:
         except Exception as e:
             print(f"RIDE: There was a problem loading panels position."
                   f" Please delete the definition 'AUI NB Perspective' in "
-                  f"{os.path.join(SETTINGS_DIRECTORY, 'settings.cfg')}")
+                  f"{self.settings_path or os.path.join(SETTINGS_DIRECTORY, 'settings.cfg')}")
             if not isinstance(e, IndexError):  # If is with all notebooks disabled, continue
                 raise e
         self.fileexplorerplugin = FileExplorerPlugin(self, self._controller)
@@ -155,15 +197,69 @@ class Message:
         RideSettingsChanged(keys=('Excludes', 'init'), old=None, new=None).publish()
         PUBLISHER.subscribe(self.change_locale, RideSettingsChanged)
         RideSettingsChanged(keys=('General', 'ui language'), old=None, new=None).publish()
+        PUBLISHER.subscribe(self.reload_preferences, RideSettingsChanged)
         wx.CallLater(600, ReleaseNotes(self).bring_to_front)
         return True
 
     def OnExit(self):
         PUBLISHER.unsubscribe_all()
+        self.frame.on_exit(None)
         self.Destroy()
         wx.Exit()
         return True
 
+    def reload_preferences(self, message):
+        if message.keys[0] != "General":
+            return
+        if self.preferences:
+           del self.preferences
+        if self.settings_path:
+            self.settings = RideSettings(self.settings_path)
+        self.preferences = Preferences(self.settings, self.settings_path)
+        try:
+            if message.keys[1] in ["reload", "restore"]:
+                # reload plugins (was the original idea)
+                if message.keys[1] == "reload":
+                    project_or_normal = PROJECT_SETTINGS
+                    project_or_normal_detected = PROJECT_SETTINGS_DETECTED
+                else:
+                    project_or_normal = NORMAL_SETTINGS
+                    project_or_normal_detected = NORMAL_SETTINGS_DETECTED
+
+                from .updatenotifier import _askyesno
+                if not _askyesno(_("Restart RIDE?"),
+                                 f"{FIVE_SPC}{FIVE_SPC}{FIVE_SPC}{FIVE_SPC}{FIVE_SPC}"
+                                 f"{project_or_normal_detected}{FIVE_SPC}\n\n"
+                                 f"{FIVE_SPC}{_('RIDE must be restarted to fully use these ')}{project_or_normal}"
+                                 f"{FIVE_SPC}\n"f"\n\n{FIVE_SPC}{FIVE_SPC}{FIVE_SPC}{FIVE_SPC}{FIVE_SPC}"
+                                 f"{_('Click OK to Restart RIDE!')}{FIVE_SPC}{FIVE_SPC}{FIVE_SPC}{FIVE_SPC}{FIVE_SPC}"
+                                 f"\n\n", wx.GetActiveWindow(), no_default=False):
+                    return False
+                args = [f"{'--noupdatecheck' if not self._updatecheck else ''}",
+                        f"--settingspath {message.keys[2]}", f"{message.keys[3]}"]
+                restart_RIDE(args)
+                wx.CallLater(1000, self.OnExit)
+                # The next block was an attempt to reload plugins, in particular Test Runner to
+                # load the Arguments for the project. This did not work because the plugins are
+                # loaded at creation of ui/mainframe. For now, we open a new instance of RIDE
+                # with the test suite/project argument.
+                """
+                # print("DEBUG: application.py RELOAD PLUGINS HERE!")
+                from time import sleep
+                for plu in self._plugin_loader.plugins:
+                    # print(f"DEBUG: Application RIDE plugin: {plu} {plu.name}\n"
+                    #       f"Plugin object={plu.conn_plugin}")
+                    if plu.name == 'Editor':
+                        plu.conn_plugin._show_editor()
+                    if plu.name == 'Test Runner':
+                        plu.disable()
+                        sleep(2)
+                        plu.enable()
+                        # plu.conn_plugin._show_notebook_tab()
+                """
+        except IndexError:
+            pass
+
     @staticmethod
     def _ApplyThemeToWidget(widget, fore_color=wx.BLUE, back_color=wx.LIGHT_GREY, theme: (None, dict) = None):
         if theme is None:
@@ -335,7 +431,6 @@ def _load_data(self):
             theme = self.settings.get_without_default('General')
             background = theme['background']
             foreground = theme['foreground']
-            # print(f"DEBUG: application.py RIDE _load_data CALL PROGRESS {background=} {foreground=}")
             observer = LoadProgressObserver(self.frame, background=background, foreground=foreground)
             self._controller.load_data(self.workspace_path, observer)
 
@@ -363,10 +458,18 @@ def _find_robot_installation():
             return None
 
     def _get_latest_path(self):
+        last_file = None
+        last_file_path = os.path.join(SETTINGS_DIRECTORY, 'last_file.txt')
+        if os.path.isfile(last_file_path):
+            with open(last_file_path, 'r', encoding='utf-8') as fp:
+                last_file = fp.read()
         recent = self._get_recentfiles_plugin()
         if not recent or not recent.recent_files:
-            return None
-        return recent.recent_files[0]
+            if last_file:
+                return last_file
+            else:
+                return None
+        return last_file if last_file and last_file != recent.recent_files[0] else recent.recent_files[0]
 
     def _get_recentfiles_plugin(self):
         from ..recentfiles import RecentFilesPlugin
@@ -377,6 +480,49 @@ def _get_recentfiles_plugin(self):
     def get_plugins(self):
         return self._plugin_loader.plugins
 
+    def initialize_project_settings(self, path):
+        """ Detects if exists a directory named .robot at project root, and creates ride_settings.cfg
+            if not exists, or returns the path to existing file.
+        """
+        from ..preferences import initialize_settings
+        default_dir = path if os.path.isdir(path) else os.path.dirname(path)
+        local_settings_dir = os.path.join(default_dir, '.robot')
+        old_settings_dir = self.settings_path
+        # print(f"DEBUG: Project.py Project initialize_project_settings ENTER: path={local_settings_dir}")
+        if os.path.isdir(local_settings_dir):
+            # old_settings = self.internal_settings.get_without_default('General')
+            # old_bkg = old_settings['background']
+            local_settings = os.path.join(local_settings_dir, 'ride_settings.cfg')
+            self.settings_path = local_settings
+            if os.path.isfile(local_settings):
+                # os.putenv('RIDESETTINGS', local_settings)
+                os.environ['RIDESETTINGS'] = local_settings
+                self.settings = RideSettings(local_settings)
+                # print(f"DEBUG: Project.py Project initialize_project_settings EXISTING project settings "
+                #       f"{local_settings=} \nRIDESETTINGS={os.environ['RIDESETTINGS']}"
+                #      f"\nsettings={self.dump_settings()}")
+            else:
+                default = RideSettings()
+                settings_path = default.user_path
+                new_path = initialize_settings(path=settings_path, dest_file_name=local_settings)
+                # print(f"DEBUG: Project.py Project initialize_project_settings NEW project settings new_path={new_path}"
+                #       f" local_settings={local_settings}")
+                self.settings = RideSettings(new_path)
+            # new_settings = self.settings.get_without_default('General')
+            # new_bkg = new_settings.get_without_default('background')
+            # RideSettingsChanged(keys=('General', 'background'), old=old_bkg, new=new_bkg).publish()
+        else:
+            os.environ['RIDESETTINGS'] = ''
+        # print(f"DEBUG: Project.py Project initialize_project_settings RETURNING: path={self.settings_path}")
+        if self.settings_path != old_settings_dir:
+            RideSettingsChanged(keys=('General', ), old=None, new=None).publish()
+        return self.settings_path
+
+    def dump_settings(self):
+        keys = [items for items in self.settings]
+        values = [f"{val}={self.settings[val]}" for val in keys]
+        return values
+
     def register_preference_panel(self, panel_class):
         """Add the given panel class to the list of known preference panels"""
         self.preferences.add(panel_class)

src/robotide/application/application.py

@@ -17,13 +17,14 @@
 from ..context import LOG
 
 
-def plugin_factory(application, plugin_class):
+def plugin_factory(application, plugin_class, silent=False):
     try:
         plugin = plugin_class(application)
     except Exception as e:
         print(e)
         msg, traceback = utils.get_error_details()
-        return BrokenPlugin(msg, traceback, plugin_class)
+        if not silent:
+            return BrokenPlugin(msg, traceback, plugin_class)
     else:
         return PluginConnector(plugin, application)
 

src/robotide/application/pluginconnector.py

@@ -25,9 +25,11 @@
 
 class PluginLoader(object):
 
-    def __init__(self, application, load_dirs, standard_classes):
+    def __init__(self, application, load_dirs, standard_classes, silent=False):
         self._load_errors = []
-        self.plugins = [plugin_factory(application, cls) for cls in standard_classes + self._find_classes(load_dirs)]
+        self.silent = silent
+        self.plugins = [plugin_factory(application, cls, silent) for cls in standard_classes +
+                        self._find_classes(load_dirs)]
         if self._load_errors:
             LOG.error('\n\n'.join(self._load_errors))
 
@@ -74,8 +76,8 @@ def _import_classes(self, path):
             m_module = importlib.util.module_from_spec(spec)
             spec.loader.exec_module(m_module)
         except Exception as err:
-            self._load_errors.append("Importing plugin module '%s' failed:\n%s"
-                                     % (path, err))
+            if not self.silent:
+                self._load_errors.append(f"Importing plugin module '{path}' failed:\n{err}")
             return []
         return [cls for _, cls in
                 inspect.getmembers(m_module, predicate=inspect.isclass)]

src/robotide/application/pluginloader.py

@@ -175,6 +175,8 @@ def set_content(self, html_win, content):
 </ul>
 <p><strong>New Features and Fixes Highlights</strong></p>
 <ul class="simple">
+<li>Added Project Settings concept. The Project Settings is a  file named <b>ride_settings.cfg</b> inside a directory 
+named <b>.robot</b> located in the Test Suite directory.</li>
 <li>Fixed crash when renaming test cases names on Tree (Project Explorer), by cancelling with Escape or by adding a Space
  in the end.</li>
 <li>Fixed missing text colorization in suites and test settings on Grid Editor.</li>
@@ -243,7 +245,7 @@ def set_content(self, html_win, content):
 <pre class="literal-block">python -m robotide.postinstall -install</pre>
 <p>or</p>
 <pre class="literal-block">ride_postinstall.py -install</pre>
-<p>RIDE {VERSION} was released on 17/August/2025.</p>
+<p>RIDE {VERSION} was released on 16/September/2025.</p>
 <!-- <br/>
 <h3>May The Fourth Be With You!</h3>
 <h3>Celebrate the bank holiday, 10th June, Day of Portugal, Portuguese Communities and Camões!!</h3>

src/robotide/application/releasenotes.py

@@ -276,6 +276,8 @@ def _subscribe_to_events(self):
 
     def on_settings_changed(self, message):
         """Updates settings"""
+        if message.keys[0] == "General":
+            return
         section, setting = message.keys
         # print("DEBUG: enter OnSettingsChanged section %s" % (section))
         if section == 'Test Run':  # DEBUG temporarily we have two sections
@@ -1383,6 +1385,8 @@ def __init__(self, editor, settings):
 
     def on_settings_changed(self, message):
         """Redraw colors and font if settings are modified"""
+        if message.keys[0] == "General":
+            return
         section, _ = message.keys
         if section == 'Test Runner':
             self._set_styles()