Implementation of Design Queries in Rego (#68)

Author: Nfsaavedra

glitch/analysis/design/imperative_abstraction.py

@@ -4,6 +4,8 @@
 from glitch.analysis.design.smell_checker import DesignSmellChecker
 from glitch.repr.inter import *
 
+# Deprecated: This rule has been rewritten in Rego.
+# This is kept for reference and possible future use since there are no tests for the Rego version yet.
 
 class ImperativeAbstraction(DesignSmellChecker):
     def __count_atomic_units(self, ub: UnitBlock) -> Tuple[int, int]:

glitch/analysis/design/long_resource.py

@@ -16,11 +16,7 @@ def __init__(self, tech: Tech, fallback: set[str]) -> None:
         from glitch.analysis.design.duplicate_block import DuplicateBlock
         from glitch.analysis.design.imperative_abstraction import ImperativeAbstraction
         from glitch.analysis.design.improper_alignment import ImproperAlignmentTabs, ImproperAlignment, PuppetImproperAlignment
-        from glitch.analysis.design.long_resource import LongResource
         from glitch.analysis.design.long_statement import LongStatement
-        from glitch.analysis.design.misplaced_attribute import ChefMisplacedAttribute, PuppetMisplacedAttribute
-        from glitch.analysis.design.multifaceted_abstraction import MultifacetedAbstraction
-        from glitch.analysis.design.too_many_variables import TooManyVariables
 
         DESIGN_CHECKER_ERRORS: Dict[Type[DesignSmellChecker], str] = {
             UnguardedVariable: "implementation_unguarded_variable",
@@ -29,12 +25,7 @@ def __init__(self, tech: Tech, fallback: set[str]) -> None:
             ImproperAlignmentTabs: "implementation_improper_alignment",
             ImproperAlignment: "implementation_improper_alignment",
             PuppetImproperAlignment: "implementation_improper_alignment",
-            LongResource: "design_long_resource",
             LongStatement: "implementation_long_statement",
-            ChefMisplacedAttribute: "design_misplaced_attribute",
-            PuppetMisplacedAttribute: "design_misplaced_attribute",
-            MultifacetedAbstraction: "design_multifaceted_abstraction",
-            TooManyVariables: "implementation_too_many_variables"
         }
 
         self.checkers: List[DesignSmellChecker] = []
@@ -95,12 +86,6 @@ def check_unitblock(self, u: UnitBlock, file: str) -> List[Error]:
         else:
             self.code_lines = []
 
-        self.first_non_comm_line = inf
-        for i, line in enumerate(self.code_lines):
-            if not line.startswith(self.comment):
-                self.first_non_comm_line = i + 1
-                break
-
         self.variable_stack.append(len(self.variables_names))
         for attr in u.attributes:
             self.variables_names.append(attr.name)
@@ -165,10 +150,7 @@ def check_variable(self, v: Variable, file: str) -> list[Error]:
         return []
 
     def check_comment(self, c: Comment, file: str) -> list[Error]:
-        errors: List[Error] = []
-        if c.line >= self.first_non_comm_line:
-            errors.append(Error("design_avoid_comments", c, file, repr(c)))
-        return errors
+        return []
 
 
 # NOTE: in the end of the file to avoid circular import

glitch/analysis/design/misplaced_attribute.py

@@ -0,0 +1,35 @@
+package glitch
+
+import data.glitch_lib
+
+get_first_line(elements) = line {
+    count(elements) > 0
+    line = { elements[0].line }
+}
+get_first_line(elements) = set() {
+    count(elements) == 0
+}
+
+Glitch_Analysis[result] {
+    parent := glitch_lib._gather_parent_unit_blocks[_]
+	parent.path != ""
+    count(parent.comments) > 0
+
+    lines := { parent.line | parent.line > 0 }
+        | get_first_line(parent.atomic_units)
+        | get_first_line(parent.statements)
+        | get_first_line(parent.unit_blocks)
+
+    count(lines) > 0
+    line := min(lines)
+
+    comment := parent.comments[_]
+    comment.line >= line
+
+    result := {{
+		"type": "design_avoid_comments",
+		"element": comment,
+		"path": parent.path,
+        "description": "Avoid comments - Comments may lead to bad code or be used as a way to justify bad code."
+	}}
+}

glitch/analysis/design/multifaceted_abstraction.py

@@ -0,0 +1,24 @@
+package glitch
+
+import data.glitch_lib
+
+Glitch_Analysis[result] {
+    parent := glitch_lib._gather_parent_unit_blocks[_]
+	parent.path != ""
+
+    resources := count(glitch_lib.all_atomic_units(parent))
+    executions := count({au | 
+        au := glitch_lib.all_atomic_units(parent)[_]
+        au.type == data.design.exec_atomic_units[_]
+    })
+
+    executions > 2
+    (executions / resources) > 0.2
+
+    result := {{
+		"type": "design_imperative_abstraction",
+		"element": parent,
+		"path": parent.path,
+        "description": "Imperative abstraction - The presence of imperative statements defies the purpose of IaC declarative languages."
+	}}
+}

glitch/analysis/design/too_many_variables.py

@@ -0,0 +1,27 @@
+package glitch
+
+import data.glitch_lib
+
+Glitch_Analysis[result] {
+    parent := glitch_lib._gather_parent_unit_blocks[_]
+    parent.path != ""
+    atomic_units := glitch_lib.all_atomic_units(parent)
+    node := atomic_units[_]
+    node.type == data.design.exec_atomic_units[_]
+
+    lines := [
+        line |
+        attr := node.attributes[_]
+        line := split(attr.code, "\n")[_]
+        not regex.match("^\\s*$", line)
+    ]
+
+    count(lines) > 7
+
+    result := {{
+		"type": "design_long_resource",
+		"element": node,
+		"path": parent.path,
+        "description": "Long Resource - Long resources may decrease the readability and maintainability of the code."
+	}}
+}