Fixes and optimization (#240)

Fixes and optimization

Reviewed-by: Jiri Popelka

Author: softwarefactory-project-zuul[bot]

specfile/sections.py

@@ -12,6 +12,7 @@
     SECTION_OPTIONS,
     SIMPLE_SCRIPT_SECTIONS,
 )
+from specfile.exceptions import RPMException
 from specfile.formatter import formatted
 from specfile.macro_definitions import MacroDefinitions
 from specfile.macros import Macros
@@ -231,19 +232,29 @@ def parse(
 
         def expand(s):
             if context:
-                return context.expand(s)
+                result = context.expand(
+                    s, skip_parsing=getattr(expand, "skip_parsing", False)
+                )
+                # parse only once
+                expand.skip_parsing = True
+                return result
             return Macros.expand(s)
 
         def split_id(line):
             content = []
             separator = "\n"
             tokens = re.split(r"(\s+)", line)
-            if len(tokens) > 2:
+            if len(tokens) > 2 and tokens[-1].startswith("%"):
                 # if the last token after macro expansion starts with a newline,
                 # consider it part of section content
-                if expand(tokens[-1]).startswith("\n"):
-                    content = [tokens.pop()]
-                    separator = tokens.pop()
+                try:
+                    expanded = expand(tokens[-1])
+                except RPMException:
+                    pass
+                else:
+                    if expanded.startswith("\n"):
+                        content = [tokens.pop()]
+                        separator = tokens.pop()
             if len(tokens) > 2:
                 name = tokens[0]
                 delimiter = tokens[1]

specfile/specfile.py

@@ -64,7 +64,7 @@ def __init__(
         """
         self.autosave = autosave
         self._path = Path(path)
-        self._lines = self.path.read_text().splitlines()
+        self._lines = self._read_lines(self._path)
         self._parser = SpecParser(
             Path(sourcedir or self.path.parent), macros, force_parse
         )
@@ -101,6 +101,10 @@ def __exit__(
     ) -> None:
         self.save()
 
+    @staticmethod
+    def _read_lines(path: Path) -> List[str]:
+        return path.read_text(encoding="utf8", errors="surrogateescape").splitlines()
+
     @property
     def path(self) -> Path:
         """Path to the spec file."""
@@ -154,28 +158,33 @@ def rpm_spec(self) -> rpm.spec:
 
     def reload(self) -> None:
         """Reload the spec file content."""
-        self._lines = self.path.read_text().splitlines()
+        self._lines = self._read_lines(self.path)
 
     def save(self) -> None:
         """Save the spec file content."""
-        self.path.write_text(str(self))
+        self.path.write_text(str(self), encoding="utf8", errors="surrogateescape")
 
     def expand(
         self,
         expression: str,
         extra_macros: Optional[List[Tuple[str, str]]] = None,
+        skip_parsing: bool = False,
     ) -> str:
         """
         Expands an expression in the context of the spec file.
 
         Args:
             expression: Expression to expand.
             extra_macros: Extra macros to be defined before expansion is performed.
+            skip_parsing: Do not parse the spec file before expansion is performed.
+              Defaults to False. Mutually exclusive with extra_macros. Set this to True
+              only if you are certain that the global macro context is up-to-date.
 
         Returns:
             Expanded expression.
         """
-        self._parser.parse(str(self), extra_macros)
+        if not skip_parsing or extra_macros is not None:
+            self._parser.parse(str(self), extra_macros)
         return Macros.expand(expression)
 
     def get_active_macros(self) -> List[Macro]:

specfile/value_parser.py

@@ -312,7 +312,12 @@ def construct_regex(
 
         def expand(s):
             if context:
-                return context.expand(s)
+                result = context.expand(
+                    s, skip_parsing=getattr(expand, "skip_parsing", False)
+                )
+                # parse only once
+                expand.skip_parsing = True
+                return result
             return Macros.expand(s)
 
         def flatten(nodes):