Support exclude key on interpolation for himl (#23)

Author: ecojan

examples/complex/env=dev/region=us-east-1/cluster=cluster1/cluster.yaml

@@ -1 +1,21 @@
 cluster: cluster1
+
+testkey: |-
+  # Set to true to log user information returned from LDAP
+    verbose_logging = true
+
+    [[servers]]
+    # Ldap server host
+    host = "someaddress"
+
+    # Default port is 389 or 636 if use_ssl = true
+    port = 389
+
+    start_tls = true
+
+skipInterpolation_key: "{{`this is a {{ value }} that should not be interpolated`}}"
+skipInterpolation_key2: "before {{`this is a {{ value }} that should not be interpolated`}} after"
+skipInterpolation_dict:
+skipInterpolation_key: "{{`this is a {{ value }} that should not be interpolated`}}"
+skipInterpolation_list:
+  - "{{`this is a {{ value }} that should not be interpolated`}}"

himl/config_generator.py

@@ -17,12 +17,13 @@
 import yaml
 from deepmerge import Merger
 
-from .interpolation import InterpolationResolver, InterpolationValidator, SecretResolver, DictIterator, replace_parent_working_directory
+from .interpolation import InterpolationResolver, EscapingResolver, InterpolationValidator, SecretResolver, DictIterator, replace_parent_working_directory
 from .python_compat import iteritems, primitive_types, PY3
 from .remote_state import S3TerraformRemoteStateRetriever
 
 logger = logging.getLogger(__name__)
 
+
 class ConfigProcessor(object):
 
     def process(self, cwd=None, path=None, filters=(), exclude_keys=(), enclosing_key=None, remove_enclosing_key=None, output_format="yaml",
@@ -82,6 +83,8 @@ def process(self, cwd=None, path=None, filters=(), exclude_keys=(), enclosing_ke
         else:
             data = generator.generated_data
 
+        generator.clean_escape_characters()
+
         formatted_data = generator.output_data(data, output_format)
 
         if print_data:
@@ -271,6 +274,13 @@ def resolve_secrets(self, default_aws_profile):
     def validate_interpolations(self):
         self.interpolation_validator.check_all_interpolations_resolved(self.generated_data)
 
+    def clean_escape_characters(self):
+        """
+        Method should clean the escaping characters {{` and `}} from all escaped values
+        """
+        resolver = EscapingResolver()
+        self.generated_data = resolver.resolve_escaping(self.generated_data)
+
     @staticmethod
     def should_use_block(value):
         """

himl/interpolation.py

@@ -15,11 +15,21 @@
 
 
 def is_interpolation(value):
-    return isinstance(value, string_types) and '{{' in value and '}}' in value
+    return isinstance(value, string_types) and '{{' in value and '}}' in value \
+           and not is_escaped_interpolation(value)
+
+
+def is_escaped_interpolation(value):
+    return isinstance(value, string_types) and '{{`' in value and '`}}' in value
+
+
+def is_fully_escaped_interpolation(value):
+    return isinstance(value, string_types) and value.startswith('{{`') and value.endswith('`}}')
 
 
 def is_full_interpolation(value):
-    return is_interpolation(value) and value.startswith('{{') and value.endswith('}}')
+    return is_interpolation(value) and value.startswith('{{') and value.endswith('}}') \
+           and not is_fully_escaped_interpolation(value)
 
 
 def remove_white_spaces(value):
@@ -47,6 +57,19 @@ def resolve_interpolations(self, data):
         return data
 
 
+class EscapingResolver(object):
+
+    def resolve_escaping(self, data):
+        """
+        Should do one last check through all values to ensure the ones that were escaped are cleaned of the escape
+        sequence
+        """
+        from_dict_injector = DictEscapingResolver(data, FromDictInjector())
+        from_dict_injector.clean_escapes(data)
+
+        return data
+
+
 class SecretResolver(object):
 
     def resolve_secrets(self, data, default_aws_profile):
@@ -81,6 +104,21 @@ def loop_all_items(self, data, process_func):
         return data
 
 
+class AbstractEscapingResolver(DictIterator):
+
+    def clean_escapes(self, data):
+        return self.loop_all_items(data, self.clean_escape)
+
+    def clean_escape(self, line):
+        # Check if line is escaped
+        if not is_escaped_interpolation(line):
+            return line
+        return self.do_clean_escapes(line)
+
+    def do_clean_escapes(self, line):
+        pass
+
+
 class AbstractInterpolationResolver(DictIterator):
 
     def resolve_interpolations(self, data):
@@ -97,6 +135,18 @@ def do_resolve_interpolation(self, line):
         pass
 
 
+class DictEscapingResolver(AbstractEscapingResolver):
+    def __init__(self, data, from_dict_injector):
+        AbstractEscapingResolver.__init__(self)
+        self.data = data
+        self.from_dict_injector = from_dict_injector
+        self.full_blob_injector = FullBlobInjector()
+
+    def do_clean_escapes(self, line):
+        updated_line = self.from_dict_injector.resolve(line, self.data)
+        return self.full_blob_injector.clean(updated_line)
+
+
 class DictInterpolationResolver(AbstractInterpolationResolver):
     def __init__(self, data, from_dict_injector):
         AbstractInterpolationResolver.__init__(self)
@@ -178,6 +228,27 @@ def resolve(self, line, data):
 
         return resolved_value if is_valid_value else line
 
+    def clean(self, line):
+        # {{` something {{ value }} `}}
+        if is_fully_escaped_interpolation(line):
+            resolved_value = self.get_value_from_escaping(line)
+            is_valid_value = resolved_value is not None
+
+            return resolved_value if is_valid_value else line
+
+        # before {{` {{value}} `}} after
+        elif is_escaped_interpolation(line):
+            prefix = line[0:line.find('{{`')]
+            escaping_string = line[line.find('{{`'):line.find('`}}') + 3]
+            suffix = line[line.find('`}}') + 3:len(line)]
+            resolved_value = prefix + self.get_value_from_escaping(escaping_string) + suffix
+            is_valid_value = resolved_value is not None
+
+            return resolved_value if is_valid_value else line
+
+        # nothing to clean
+        return line
+
     @staticmethod
     def get_inner_value(keys, data):
         for key in keys:
@@ -194,3 +265,11 @@ def get_keys_from_interpolation(line):
         line = line[2:-2]
 
         return line.split('.')
+
+    @staticmethod
+    def get_value_from_escaping(line):
+        # remove {{` and `}}
+        line = line[3:-3]
+
+        return line
+