ara-cli 0.1.9.69__py3-none-any.whl → 0.1.10.8__py3-none-any.whl

ara_cli/artefact_models/userstory_artefact_model.py

@@ -1,5 +1,5 @@
 from ara_cli.artefact_models.artefact_model import Artefact, ArtefactType, Intent
-from pydantic import Field, field_validator
+from pydantic import Field, field_validator, model_validator
 from typing import List, Tuple
 
 
@@ -47,39 +47,37 @@ class UserstoryIntent(Intent):
 
     @classmethod
     def deserialize_from_lines(cls, lines: List[str], start_index: int = 0) -> 'UserstoryIntent':
-        in_order_to = None
-        as_a = None
-        i_want = None
-
-        in_order_to_prefix = "In order to "
-        as_a_prefix = "As a "
-        as_a_prefix_alt = "As an "
-        i_want_prefix = "I want "
+        prefixes = [
+            ("In order to ", "in_order_to"),
+            ("As a ", "as_a"),
+            ("As an ", "as_a"),
+            ("I want ", "i_want"),
+        ]
+        found = {"in_order_to": None, "as_a": None, "i_want": None}
+
+        def match_and_store(line):
+            for prefix, field in prefixes:
+                if line.startswith(prefix) and found[field] is None:
+                    found[field] = line[len(prefix):].strip()
+                    return True
+            return False
 
         index = start_index
-        while index < len(lines) and (not in_order_to or not as_a or not i_want):
-            line = lines[index].strip()
-            if line.startswith(in_order_to_prefix) and not in_order_to:
-                in_order_to = line[len(in_order_to_prefix):].strip()
-            elif line.startswith(as_a_prefix) and not as_a:
-                as_a = line[len(as_a_prefix):].strip()
-            elif line.startswith(as_a_prefix_alt) and not as_a:
-                as_a = line[len(as_a_prefix_alt):].strip()
-            elif line.startswith(i_want_prefix) and not i_want:
-                i_want = line[len(i_want_prefix):].strip()
+        while index < len(lines) and any(v is None for v in found.values()):
+            match_and_store(lines[index].strip())
             index += 1
 
-        if not in_order_to:
+        if not found["in_order_to"]:
             raise ValueError("Could not find 'In order to' line")
-        if not as_a:
+        if not found["as_a"]:
             raise ValueError("Could not find 'As a' line")
-        if not i_want:
+        if not found["i_want"]:
             raise ValueError("Could not find 'I want' line")
 
         return cls(
-            in_order_to=in_order_to,
-            as_a=as_a,
-            i_want=i_want
+            in_order_to=found["in_order_to"],
+            as_a=found["as_a"],
+            i_want=found["i_want"]
         )
 
 
@@ -94,6 +92,18 @@ class UserstoryArtefact(Artefact):
         default_factory=list,
         description="Rules the userstory defines. It is recommended to create rules to clarify the desired outcome")
 
+    @model_validator(mode='after')
+    def check_for_misplaced_content(self) -> 'UserstoryArtefact':
+        if self.description:
+            desc_lines = self.description.split('\n')
+            for line in desc_lines:
+                stripped_line = line.strip()
+                if stripped_line.startswith("Rule:"):
+                    raise ValueError("Found 'Rule:' inside description. Rules must be defined before the 'Description:' section.")
+                if stripped_line.startswith("Estimate:"):
+                    raise ValueError("Found 'Estimate:' inside description. Estimate must be defined before the 'Description:' section.")
+        return self
+
     @field_validator('artefact_type')
     def validate_artefact_type(cls, v):
         if v != ArtefactType.userstory:
@@ -173,7 +183,7 @@ class UserstoryArtefact(Artefact):
         rules = self._serialize_rules()
 
         lines = []
-        if self.tags:
+        if tags:  # Changed from self.tags to tags to include all tag types
             lines.append(tags)
         lines.append(title)
         lines.append("")
@@ -190,4 +200,4 @@ class UserstoryArtefact(Artefact):
         lines.append(description)
         lines.append("")
 
-        return '\n'.join(lines)
+        return '\n'.join(lines)

ara_cli/artefact_models/vision_artefact_model.py

@@ -76,54 +76,35 @@ class VisionIntent(Intent):
 
     @classmethod
     def deserialize_from_lines(cls, lines: List[str], start_index: int = 0) -> 'VisionIntent':
+        prefixes = [
+            ("For ", "for_"),
+            ("Who ", "who"),
+            ("The ", "the"),
+            ("That ", "that"),
+            ("Unlike ", "unlike"),
+            ("Our product ", "our_product"),
+        ]
+        found = {field: "" for _, field in prefixes}
+
+        # Find the first "For " line, if it exists
         intent_start_index = start_index
-
-        for_ = ""
-        who = ""
-        the = ""
-        that = ""
-        unlike = ""
-        our_product = ""
-
-        for_prefix = "For "
-        who_prefix = "Who "
-        the_prefix = "The "
-        that_prefix = "That "
-        unlike_prefix = "Unlike "
-        our_product_prefix = "Our product "
-
         for i in range(start_index, len(lines)):
-            if lines[i].startswith(for_prefix):
+            if lines[i].startswith("For "):
                 intent_start_index = i
                 break
 
+        def match_and_store(line):
+            for prefix, field in prefixes:
+                if line.startswith(prefix) and not found[field]:
+                    found[field] = line[len(prefix):].strip()
+                    return
+
         index = intent_start_index
-        if index < len(lines) and lines[index].startswith(for_prefix):
-            for_ = lines[index][len(for_prefix):]
-            index = index + 1
-        if index < len(lines) and lines[index].startswith(who_prefix):
-            who = lines[index][len(who_prefix):]
-            index = index + 1
-        if index < len(lines) and lines[index].startswith(the_prefix):
-            the = lines[index][len(the_prefix):]
-            index = index + 1
-        if index < len(lines) and lines[index].startswith(that_prefix):
-            that = lines[index][len(that_prefix):]
-            index = index + 1
-        if index < len(lines) and lines[index].startswith(unlike_prefix):
-            unlike = lines[index][len(unlike_prefix):]
-            index = index + 1
-        if index < len(lines) and lines[index].startswith(our_product_prefix):
-            our_product = lines[index][len(our_product_prefix):]
-
-        return cls(
-            for_=for_,
-            who=who,
-            the=the,
-            that=that,
-            unlike=unlike,
-            our_product=our_product,
-        )
+        while index < len(lines) and any(not v for v in found.values()):
+            match_and_store(lines[index])
+            index += 1
+
+        return cls(**found)
 
 
 class VisionArtefact(Artefact):

ara_cli/artefact_reader.py

@@ -1,3 +1,4 @@
+from . import error_handler
 from ara_cli.classifier import Classifier
 from ara_cli.file_classifier import FileClassifier
 from ara_cli.artefact_models.artefact_model import Artefact
@@ -10,20 +11,20 @@ import re
 
 class ArtefactReader:
     @staticmethod
-    def read_artefact(artefact_name, classifier) -> tuple[str, dict[str, str]]:
+    def read_artefact_data(artefact_name, classifier, classified_file_info = None) -> tuple[str, dict[str, str]]:
         if not Classifier.is_valid_classifier(classifier):
-            print("Invalid classifier provided. Please provide a valid classifier.")
-            return None, None
+            raise ValueError("Invalid classifier provided. Please provide a valid classifier.")
 
-        file_classifier = FileClassifier(os)
-        classified_file_info = file_classifier.classify_files()
+        if not classified_file_info:
+            file_classifier = FileClassifier(os)
+            classified_file_info = file_classifier.classify_files()
         artefact_info_of_classifier = classified_file_info.get(classifier, [])
 
         for artefact_info in artefact_info_of_classifier:
             file_path = artefact_info["file_path"]
             artefact_title = artefact_info["title"]
             if artefact_title == artefact_name:
-                with open(file_path, 'r') as file:
+                with open(file_path, 'r', encoding='utf-8') as file:
                     content = file.read()
                 return content, artefact_info
 
@@ -36,25 +37,14 @@ class ArtefactReader:
         return None, None
 
     @staticmethod
-    def read_single_artefact(artefact_name, classifier, classified_file_info=None) -> Artefact:
-        if not Classifier.is_valid_classifier(classifier):
-            print("Invalid classifier provided. Please provide a valid classifier.")
+    def read_artefact(artefact_name, classifier, classified_file_info=None) -> Artefact:
+        content, artefact_info = ArtefactReader.read_artefact_data(artefact_name, classifier, classified_file_info)
+        if not content or not artefact_info:
             return None
-        if not classified_file_info:
-            file_classifier = FileClassifier(os)
-            classified_file_info = file_classifier.classify_files()
-        artefact_info_of_classifier = classified_file_info.get(classifier, [])
-
-        for artefact_info in artefact_info_of_classifier:
-            file_path = artefact_info["file_path"]
-            artefact_title = artefact_info["title"]
-            if artefact_title == artefact_name:
-                with open(file_path, 'r') as file:
-                    content = file.read()
-                artefact = artefact_from_content(content)
-                artefact._file_path = file_path
-                return artefact
-        return None
+        file_path = artefact_info["file_path"]
+        artefact = artefact_from_content(content)
+        artefact._file_path = file_path
+        return artefact
 
     @staticmethod
     def extract_parent_tree(artefact_content):
@@ -84,7 +74,6 @@ class ArtefactReader:
 
     @staticmethod
     def read_artefacts(classified_artefacts=None, file_system=os, tags=None) -> Dict[str, List[Artefact]]:
-        from ara_cli.artefact_models.artefact_load import artefact_from_content
 
         if classified_artefacts is None:
             file_classifier = FileClassifier(file_system)
@@ -94,29 +83,17 @@ class ArtefactReader:
                      for artefact_type in classified_artefacts.keys()}
         for artefact_type, artefact_info_dicts in classified_artefacts.items():
             for artefact_info in artefact_info_dicts:
+                title = artefact_info["title"]
                 try:
-                    with open(artefact_info["file_path"], 'r') as file:
-                        content = file.read()
-                    artefact = artefact_from_content(content)
-                    if not artefact:
-                        continue
-                    # Store the full file path in the artefact
-                    artefact._file_path = artefact_info["file_path"]
+                    artefact = ArtefactReader.read_artefact(title, artefact_type, classified_artefacts)
                     artefacts[artefact_type].append(artefact)
-                    # else:
-                        # Include file path if deserialization fails
-                        # FIXME: LOOK INTO IT
-                        # artefacts[artefact_type].append(file_path)
-                except Exception:
-                    # TODO: catch only specific exceptions
-                    # TODO: implament error message for deserialization or "ara scan" or "ara autofix"
-                    # print(f"Warning: Could not deserialize artefact at {artefact_info}: {e}")
-                    # artefacts[artefact_type].append(file_path)
+                except Exception as e:
+                    error_handler.report_error(e, f"reading {artefact_type} '{title}'")
                     continue
         return artefacts
 
     @staticmethod
-    def find_children(artefact_name, classifier, artefacts_by_classifier={}, classified_artefacts=None):
+    def find_children(artefact_name, classifier, artefacts_by_classifier=None, classified_artefacts=None):
         artefacts_by_classifier = artefacts_by_classifier or {}
         filtered_artefacts = {k: [] for k in artefacts_by_classifier.keys()}
 
@@ -125,73 +102,97 @@ class ArtefactReader:
 
         for artefact_classifier, artefacts in classified_artefacts.items():
             for artefact in artefacts:
-                if not isinstance(artefact, Artefact):
-                    continue
+                ArtefactReader._process_artefact(
+                    artefact, artefact_name, classifier, filtered_artefacts
+                )
 
-                try:
-                    contribution = artefact.contribution
-                    if (contribution and
-                        contribution.artefact_name == artefact_name and
-                            contribution.classifier == classifier):
-
-                        file_classifier = artefact._file_path.split('.')[-1]
+        return ArtefactReader.merge_dicts(artefacts_by_classifier, filtered_artefacts)
 
-                        if file_classifier not in filtered_artefacts:
-                            filtered_artefacts[file_classifier] = []
-                        filtered_artefacts[file_classifier].append(artefact)
+    @staticmethod
+    def _process_artefact(artefact, artefact_name, classifier, filtered_artefacts):
+        if not isinstance(artefact, Artefact):
+            return
+        contribution = getattr(artefact, 'contribution', None)
+        if not contribution:
+            return
+        if getattr(contribution, 'artefact_name', None) != artefact_name:
+            return
+        if getattr(contribution, 'classifier', None) != classifier:
+            return
 
-                except AttributeError as e:
-                    continue
-
-        return ArtefactReader.merge_dicts(artefacts_by_classifier, filtered_artefacts)
+        file_classifier = getattr(artefact, '_file_path', '').split('.')[-1]
+        if file_classifier not in filtered_artefacts:
+            filtered_artefacts[file_classifier] = []
+        filtered_artefacts[file_classifier].append(artefact)
 
     @staticmethod
     def step_through_value_chain(
             artefact_name,
             classifier,
-            artefacts_by_classifier={},
-            classified_artefacts: dict[str, list[Artefact]] | None = None
+            artefacts_by_classifier=None,
+            classified_artefacts: dict[str, list['Artefact']] | None = None
     ):
         from ara_cli.artefact_models.artefact_load import artefact_from_content
 
+        artefacts_by_classifier = artefacts_by_classifier or {}
+
         if classified_artefacts is None:
             classified_artefacts = ArtefactReader.read_artefacts()
 
-        if classifier not in artefacts_by_classifier:
-            artefacts_by_classifier[classifier] = []
+        ArtefactReader._ensure_classifier_key(classifier, artefacts_by_classifier)
 
-        artefact = next(filter(
-            lambda x: x.title == artefact_name, classified_artefacts[classifier]
-        ))
+        artefact = ArtefactReader._find_artefact_by_name(
+            artefact_name,
+            classified_artefacts.get(classifier, [])
+        )
 
-        if not artefact:
-            return
-        if artefact in artefacts_by_classifier[classifier]:
+        if not artefact or artefact in artefacts_by_classifier[classifier]:
             return
 
         artefacts_by_classifier[classifier].append(artefact)
 
-        parent = artefact.contribution
-        if parent and parent.artefact_name and parent.classifier:
-            parent_name = parent.artefact_name
-            parent_classifier = parent.classifier
-
-            parent_classifier_artefacts = classified_artefacts[parent_classifier]
-            all_artefact_names = [x.title for x in parent_classifier_artefacts]
-
-            if parent_name not in all_artefact_names:
-                if parent_name is not None:
-                    suggest_close_name_matches_for_parent(
-                        artefact_name,
-                        all_artefact_names,
-                        parent_name
-                    )
-                print()
-                return
-
-            ArtefactReader.step_through_value_chain(
-                artefact_name=parent_name,
-                classifier=parent_classifier,
-                artefacts_by_classifier=artefacts_by_classifier,
-                classified_artefacts=classified_artefacts
+        parent = getattr(artefact, 'contribution', None)
+        if not ArtefactReader._has_valid_parent(parent):
+            return
+
+        parent_name = parent.artefact_name
+        parent_classifier = parent.classifier
+
+        parent_classifier_artefacts = classified_artefacts.get(parent_classifier, [])
+        all_artefact_names = [x.title for x in parent_classifier_artefacts]
+
+        if parent_name not in all_artefact_names:
+            ArtefactReader._suggest_parent_name_match(
+                artefact_name, all_artefact_names, parent_name
+            )
+            print()
+            return
+
+        ArtefactReader.step_through_value_chain(
+            artefact_name=parent_name,
+            classifier=parent_classifier,
+            artefacts_by_classifier=artefacts_by_classifier,
+            classified_artefacts=classified_artefacts
+        )
+
+    @staticmethod
+    def _ensure_classifier_key(classifier, artefacts_by_classifier):
+        if classifier not in artefacts_by_classifier:
+            artefacts_by_classifier[classifier] = []
+
+    @staticmethod
+    def _find_artefact_by_name(artefact_name, artefacts):
+        return next((x for x in artefacts if x.title == artefact_name), None)
+
+    @staticmethod
+    def _has_valid_parent(parent):
+        return parent and getattr(parent, 'artefact_name', None) and getattr(parent, 'classifier', None)
+
+    @staticmethod
+    def _suggest_parent_name_match(artefact_name, all_artefact_names, parent_name):
+        if parent_name is not None:
+            suggest_close_name_matches_for_parent(
+                artefact_name,
+                all_artefact_names,
+                parent_name
             )

ara_cli/artefact_renamer.py

@@ -1,9 +1,10 @@
-import os
 from functools import lru_cache
 from ara_cli.classifier import Classifier
 from ara_cli.artefact_link_updater import ArtefactLinkUpdater
 from ara_cli.template_manager import DirectoryNavigator
+import os
 import re
+import warnings
 
 
 class ArtefactRenamer:
@@ -22,6 +23,8 @@ class ArtefactRenamer:
         return re.compile(pattern)
 
     def rename(self, old_name, new_name, classifier):
+        import shutil
+
         original_directory = self.navigate_to_target()
 
         if not new_name:
@@ -47,7 +50,8 @@ class ArtefactRenamer:
         if self.file_system.path.exists(new_file_path):
             raise FileExistsError(f"The new file name {new_file_path} already exists.")
         if self.file_system.path.exists(new_dir_path):
-            raise FileExistsError(f"The new directory name {new_dir_path} already exists.")
+            warnings.warn(f"The new directory name {new_dir_path} already exists. It will be replaced by the artefact's data directory or removed entirely.", UserWarning)
+            shutil.rmtree(new_dir_path)
 
         # Perform the renaming of the file and directory
         self.file_system.rename(old_file_path, new_file_path)
@@ -75,7 +79,7 @@ class ArtefactRenamer:
             raise ValueError(f"Invalid classifier: {classifier}")
 
         # Read the file content
-        with open(artefact_path, 'r') as file:
+        with open(artefact_path, 'r', encoding='utf-8') as file:
             content = file.read()
 
         # Find the old title line
@@ -89,5 +93,5 @@ class ArtefactRenamer:
         new_content = content.replace(old_title_line, new_title_line, 1)
 
         # Write the updated content back to the file
-        with open(artefact_path, 'w') as file:
+        with open(artefact_path, 'w', encoding='utf-8') as file:
             file.write(new_content)

ara_cli/artefact_scan.py

@@ -2,24 +2,87 @@ from textwrap import indent
 import os
 
 
-def check_file(file_path, artefact_class):
+def is_contribution_valid(contribution, classified_artefact_info) -> bool:
+    from ara_cli.artefact_fuzzy_search import extract_artefact_names_of_classifier
+    if not contribution or not contribution.artefact_name or not contribution.classifier:
+        return True
+
+    all_artefact_names = extract_artefact_names_of_classifier(
+        classified_files=classified_artefact_info,
+        classifier=contribution.classifier
+    )
+    if contribution.artefact_name not in all_artefact_names:
+        return False
+    return True
+
+
+def is_rule_valid(contribution, classified_artefact_info) -> bool:
+    from ara_cli.artefact_reader import ArtefactReader
+
+    if not contribution or not contribution.artefact_name or not contribution.classifier:
+        return True
+    rule = contribution.rule
+    if not rule:
+        return True
+    parent = ArtefactReader.read_artefact(contribution.artefact_name, contribution.classifier)
+    if not parent:
+        return True
+    rules = parent.rules
+    if not rules or rule not in rules:
+        return False
+    return True
+
+
+def check_contribution(contribution, classified_artefact_info, file_path) -> tuple[bool, str]:
+    if not contribution:
+        return True, None
+
+    if not is_contribution_valid(contribution, classified_artefact_info):
+        reason = (f"Invalid Contribution Reference: The contribution references "
+                  f"'{contribution.classifier}' artefact '{contribution.artefact_name}' "
+                  f"which does not exist.")
+        return False, reason
+
+    if not is_rule_valid(contribution, classified_artefact_info):
+        reason = (f"Rule Mismatch: The contribution references "
+                  f"rule '{contribution.rule}' which the parent "
+                  f"{contribution.classifier} '{contribution.artefact_name}' does not have.")
+        return False, reason
+    return True, None
+
+
+def check_file(file_path, artefact_class, classified_artefact_info=None):
     from pydantic import ValidationError
+    from ara_cli.file_classifier import FileClassifier
+
     try:
         with open(file_path, "r", encoding="utf-8") as f:
             content = f.read()
     except OSError as e:
         return False, f"File error: {e}"
+
+    if not classified_artefact_info:
+        file_classifier = FileClassifier(os)
+        classified_artefact_info = file_classifier.classify_files()
+
     try:
         artefact_instance = artefact_class.deserialize(content)
 
         base_name = os.path.basename(file_path)
         file_name_without_ext, _ = os.path.splitext(base_name)
 
+        # Check title and file name matching
         if artefact_instance.title != file_name_without_ext:
             reason = (f"Filename-Title Mismatch: The file name '{file_name_without_ext}' "
                       f"does not match the artefact title '{artefact_instance.title}'.")
             return False, reason
 
+        contribution = artefact_instance.contribution
+
+        contribution_valid, reason = check_contribution(contribution, classified_artefact_info, file_path)
+        if not contribution_valid:
+            return False, reason
+
         return True, None
     except (ValidationError, ValueError, AssertionError) as e:
         return False, str(e)
@@ -37,7 +100,7 @@ def find_invalid_files(classified_artefact_info, classifier):
             continue
         if ".data" in artefact_info["file_path"]:
             continue
-        is_valid, reason = check_file(artefact_info["file_path"], artefact_class)
+        is_valid, reason = check_file(artefact_info["file_path"], artefact_class, classified_artefact_info)
         if not is_valid:
             invalid_files.append((artefact_info["file_path"], reason))
     return invalid_files
@@ -45,7 +108,7 @@ def find_invalid_files(classified_artefact_info, classifier):
 
 def show_results(invalid_artefacts):
     has_issues = False
-    with open("incompatible_artefacts_report.md", "w") as report:
+    with open("incompatible_artefacts_report.md", "w", encoding="utf-8") as report:
         report.write("# Artefact Check Report\n\n")
         for classifier, files in invalid_artefacts.items():
             if files: