def _transform_func_get_att()

in rostran/providers/terraform/template.py [0:0]

• 55 lines of code
• 14 McCabe index (conditional complexity)

    def _transform_func_get_att(self, resource_id, attrname):
        tf_resource_type = None
        for resource in self.plan[self.P_PLANNED_VALUES][self.P_ROOT_MODULE].get(
            self.P_RESOURCES, []
        ):
            if resource_id == resource[self.P_ADDRESS]:
                tf_resource_type = resource[self.P_TYPE]

        resource_rule: ResourceRule = self.rule_manager.resource_rules.get(
            tf_resource_type
        )
        if tf_resource_type is None or resource_rule is None:
            typer.secho(
                f"Resource type {tf_resource_type!r} is not supported and will be ignored.",
                fg="yellow",
            )
            return None

        if (
            attrname not in resource_rule.attributes
            or "To" not in resource_rule.attributes[attrname]
        ):
            typer.secho(
                f"Resource attribute {attrname!r} of {tf_resource_type!r} is not supported and will be ignored.",
                fg="yellow",
            )
            return None

        def parse(n):
            names = n.split(".")
            final_attrname = names[0]
            result = {"Fn::GetAtt": [resource_id, final_attrname]}

            if len(names) > 1:
                # using JQ to get value
                jq_expr = "."
                for name in names[1:]:
                    try:
                        index = int(name)
                        jq_expr += f"[{index}]"
                    except ValueError:
                        jq_expr += f".{name}"
                result = {"Fn::Jq": ["First", jq_expr, result]}
            return result

        attr_rule = resource_rule.attributes[attrname]
        to_name = attr_rule["To"]
        if isinstance(to_name, str):
            final_value = parse(to_name)
        elif isinstance(to_name, (list, tuple)):
            final_value = [parse(each) for each in to_name]
        else:
            raise InvalidRuleSchema(
                path=resource_rule.rule_id,
                reason=f"The type of To={to_name} is invalid. Expect str or list",
            )

        handler_name = attr_rule.get("Handler")
        if handler_name is not None:
            handler_func = getattr(basic_handler_module, handler_name)
            final_value = handler_func(final_value, False)

        return final_value