cfn-check 0.3.3__py3-none-any.whl → 0.5.0__py3-none-any.whl

cfn_check/cli/render.py

@@ -0,0 +1,83 @@
+
+from async_logging import LogLevelName, Logger, LoggingConfig
+from cocoa.cli import CLI
+
+from cfn_check.cli.utils.files import load_templates, write_to_file
+from cfn_check.rendering import Renderer
+from cfn_check.logging.models import InfoLog
+
+
+@CLI.command(
+        display_help_on_error=False
+)
+async def render(
+    path: str,
+    output_file: str  = 'rendered.yml',
+    parameters: list[str] | None = None,
+    references: list[str] | None = None,
+    tags: list[str] = [
+        'Ref',
+        'Sub',
+        'Join',
+        'Select',
+        'Split',
+        'GetAtt',
+        'GetAZs',
+        'ImportValue',
+        'Equals',
+        'If',
+        'Not',
+        'And',
+        'Or',
+        'Condition',
+        'FindInMap',
+    ],
+    log_level: LogLevelName = 'info',
+):
+    """
+    Render a Cloud Formation template
+
+    @param output_file Path to output the rendered CloudFormation template to
+    @param parameters A list of <key>=<value> input Parameters to use
+    @param references A list of <key>=<value> input !Ref values to use
+    @param tags List of CloudFormation intrinsic function tags
+    @param log_level The log level to use
+    """
+    logging_config = LoggingConfig()
+    logging_config.update(
+        log_level=log_level,
+        log_output='stderr',
+    )
+
+    parsed_parameters: dict[str, str] | None = None
+    if parameters:
+        parsed_parameters = dict([
+            parameter.split('=', maxsplit=1) for parameter in parameters if len(parameter.split('=', maxsplit=1)) > 0
+        ])
+
+    parsed_references: dict[str, str] | None = None
+    if references:
+        parsed_references = dict([
+            reference.split('=', maxsplit=1) for reference in references if len(reference.split('=', maxsplit=1)) > 0
+        ])
+
+    logger = Logger()
+
+    templates = await load_templates(
+        path,
+        tags,
+    )
+
+    assert len(templates) == 1 , '❌ Can only render one file'
+
+    _, template = templates[0]
+    renderer = Renderer()
+    rendered = renderer.render(
+        template,
+        parameters=parsed_parameters,
+        references=parsed_references,
+    )
+
+    await write_to_file(output_file, rendered)
+
+    await logger.log(InfoLog(message=f'✅ {path} template rendered'))

cfn_check/cli/root.py

@@ -7,6 +7,7 @@ from cocoa.ui.components.terminal import Section, SectionConfig
 from cocoa.ui.components.header import Header, HeaderConfig
 from cocoa.ui.components.terminal import Terminal, EngineConfig
 
+from .render import render
 from .validate import validate
 
 async def create_header(
@@ -47,7 +48,8 @@ async def create_header(
 
 
 
-@CLI.root(  
+@CLI.root( 
+    render, 
     validate,
     global_styles=CLIStyle(
         header=create_header,

cfn_check/cli/utils/attributes.py

@@ -4,7 +4,7 @@ from cfn_check.validation.validator import Validator
 
 def bind(
     rule_set: Collection,
-    validation: Validator
+    validation: Validator,
 ):
     validation.func = validation.func.__get__(rule_set, rule_set.__class__)
     setattr(rule_set, validation.func.__name__, validation.func)

cfn_check/cli/utils/files.py

@@ -2,22 +2,24 @@
 import asyncio
 import os
 import pathlib
-import yaml
-from cfn_check.loader.loader import (
-    Loader,
-    create_tag,
-    find_templates,
-)
+from ruamel.yaml import YAML
 from cfn_check.shared.types import YamlObject, Data
 
-def open_template(path: str) -> YamlObject | None:
+
+def find_templates(path, file_pattern):
+    return list(pathlib.Path(path).rglob(file_pattern))
+
+def open_template(path: str) -> tuple[str, YamlObject] | None:
 
     if os.path.exists(path) is False:
         return None
 
     try:
-        with open(path, 'r') as f:
-            return yaml.load(f, Loader=Loader)
+        with open(path, 'r') as yml:
+            loader = YAML(typ='rt')
+            loader.preserve_quotes = True
+            loader.indent(mapping=2, sequence=4, offset=2)
+            return (path, loader.load(yml))
     except Exception as e:
         raise e
     
@@ -38,6 +40,16 @@ async def convert_to_cwd(loop: asyncio.AbstractEventLoop):
         os.getcwd,
     )
 
+async def convert_to_absolute(path: str, loop: asyncio.AbstractEventLoop) -> str:
+    abspath = pathlib.Path(path)
+
+    return str(
+        await loop.run_in_executor(
+            None,
+            abspath.absolute,
+        )
+    )
+
 async def localize_path(path: str, loop: asyncio.AbstractEventLoop):
     localized = path.replace('~/', '')
 
@@ -89,17 +101,7 @@ async def load_templates(
 
     assert len(template_filepaths) > 0 , '❌ No matching files found'
     
-    for tag in tags:
-        new_tag = await loop.run_in_executor(
-            None,
-            create_tag,
-            tag,
-        )
-
-        Loader.add_constructor(f'!{tag}', new_tag)
-
-    
-    templates: list[Data]  = await asyncio.gather(*[
+    templates: list[tuple[str, Data]]  = await asyncio.gather(*[
         loop.run_in_executor(
             None,
             open_template,
@@ -114,3 +116,27 @@ async def load_templates(
     assert len(found_templates) > 0, "❌ Could not open any templates"
 
     return templates
+
+
+async def write_to_file(path: str, data: YamlObject):
+    loop = asyncio.get_event_loop()
+
+    if path.startswith('~/'):
+        path = await localize_path(path, loop)
+
+    output_path = await convert_to_absolute(path, loop)
+
+    await loop.run_in_executor(
+        None,
+        _write_to_file,
+        output_path,
+        data,
+    )
+
+def _write_to_file(path: str, data: YamlObject):
+    dumper = YAML(typ='rt')
+    dumper.preserve_quotes = True
+    dumper.width = 4096
+    dumper.indent(mapping=2, sequence=4, offset=2)
+    with open(path, 'w') as yml:
+        dumper.dump(data, yml)

cfn_check/cli/validate.py

@@ -58,6 +58,11 @@ async def validate(
         file_pattern=file_pattern,
     )
 
+    for file, data in templates:
+        for name, rule in rules.data.items():
+            rules.data[name] = rule()
+            rules.data[name].documents[file] = data
+
     validation_set = ValidationSet([ 
         bind(
             rule,
@@ -68,7 +73,9 @@ async def validate(
         if isinstance(validation, Validator)
     ])
     
-    if validation_error := validation_set.validate(templates):
+    if validation_error := validation_set.validate([
+        template_data for _, template_data in templates
+    ]):
         raise validation_error
     
     templates_evaluated = len(templates)

cfn_check/collection/collection.py

@@ -1,2 +1,59 @@
+from typing import Callable
+from pydantic import ValidationError
+
+from cfn_check.shared.types import Data
+from cfn_check.evaluation.evaluator import Evaluator
+
 class Collection:
-    pass
+    
+    def __init__(self):
+        self.documents: dict[str, Data] = {}
+        self._evaluator = Evaluator()
+
+    def query(
+        self,
+        query: str,
+        document: str | None = None,
+        filters: list[Callable[[Data], Data]] | None = None
+    ) -> list[Data] | None:
+
+        if document and (
+            document_data := self.documents.get(document)
+        ):
+            return self._evaluator.match(
+                document_data,
+                query,
+            )
+        
+        results: list[tuple[str, Data]] = []
+
+        for document_data in self.documents.values():
+            result = self._evaluator.match(
+                document_data,
+                query,
+            )
+
+            results.extend(result)
+        
+        filtered: list[Data] = []
+        if filters:
+            try:
+                for _, found in results:
+                    for filter in filters:
+                        found = filter(found)
+
+                        if found is None:
+                            return
+                        
+                    if found:
+                        filtered.append(found)
+            
+                return filtered
+
+            except ValidationError:
+                pass
+
+        return [
+            found for _, found in results
+        ]
+

cfn_check/evaluation/evaluator.py

@@ -7,12 +7,14 @@ from cfn_check.shared.types import (
     YamlObject,
 )
 
+from cfn_check.rendering import Renderer
 from .parsing import QueryParser
 
 class Evaluator:
 
     def __init__(self):
         self._query_parser = QueryParser()
+        self._renderer = Renderer()
 
     def match(
         self,
@@ -20,7 +22,9 @@ class Evaluator:
         path: str,
     ):
         items: Items = deque()
-        items.append(resources)
+
+        rendered = self._renderer.render(resources)
+        items.append(rendered)
 
         segments = path.split("::")[::-1]
         # Queries can be multi-segment,

cfn_check/rendering/__init__.py

@@ -0,0 +1 @@
+from .renderer import Renderer as Renderer