Skip to content
Capable Ansible Collections

capable.core212.logical

evaluate if/elseif/else/and/or/not in data.

Data embedded with single item dict keys if/elseif/else/and/or/not are evaluated and the remaining data replaces the top level if.

See example to better understand how this filte works.

Parameters

Section titled “Parameters”

data (required)

Section titled “data (required)”

Type: dict · Required: yes

Data containing logical operations.

Examples

Section titled “Examples”
# Simple if/then/else conditional
- name: simple conditional
  vars:
    data:
      if: true
      then: purple
      else: green
    result: "{{ data | logical }}"
    # result == "purple"


# if/then/elseif/else - first matching branch wins
- name: elseif chain
  vars:
    data:
      if: false
      then: first
      elseif:
        - elseif: true
          then: second
        - elseif: true
          then: third
      else: last
    result: "{{ data | logical }}"
    # result == "second"


# Nested conditionals - then/else values can themselves contain conditionals
- name: nested conditionals
  vars:
    data:
      server:
        if: true
        then:
          region:
            if: false
            then: us-east-1
            else: eu-west-1
          size: large
        else:
          region: default
          size: small
    result: "{{ data | logical }}"
    # result == {server: {region: "eu-west-1", size: "large"}}


# Complex then/else values - dicts and lists as results
- name: dict as then value
  vars:
    data:
      if: true
      then:
        name: server1
        port: 8080
        tags:
          - web
          - production
      else:
        name: fallback
        port: 80
    result: "{{ data | logical }}"
    # result == {name: "server1", port: 8080, tags: ["web", "production"]}


- name: list as then/else value
  vars:
    data:
      if: false
      then:
        - item1
        - item2
      else:
        - fallback1
        - fallback2
        - fallback3
    result: "{{ data | logical }}"
    # result == ["fallback1", "fallback2", "fallback3"]


# Missing else - returns None when condition is false and no else provided
- name: no else clause
  vars:
    data:
      if: false
      then: unreachable
    result: "{{ data | logical }}"
    # result == None


# Mixed static and conditional keys - regular keys pass through unchanged
- name: passthrough with nested conditional
  vars:
    data:
      static_key: static_value
      nested:
        if: true
        then: resolved
    result: "{{ data | logical }}"
    # result == {static_key: "static_value", nested: "resolved"}


# String booleans from Jinja2 templating
- name: string booleans
  vars:
    my_flag: true
    data:
      if: "{{ my_flag }}"
      then: resolved true
      else: resolved false
    result: "{{ data | logical }}"
    # result == "resolved true"


# Logical operators standalone
- name: and operator - true if all are true
  vars:
    data:
      and:
        - true
        - true
        - true
    result: "{{ data | logical }}"
    # result == true


- name: or operator - true if any is true
  vars:
    data:
      or:
        - false
        - true
        - false
    result: "{{ data | logical }}"
    # result == true


- name: xor operator - true if exactly one is true
  vars:
    xor_true:
      xor:
        - false
        - true
        - false
    xor_false_none:
      xor:
        - false
        - false
        - false
    xor_false_many:
      xor:
        - true
        - true
        - false
    # xor_true | logical == true  (exactly one)
    # xor_false_none | logical == false  (zero true)
    # xor_false_many | logical == false  (more than one true)


- name: not operator - flips the boolean value
  vars:
    data:
      not: false
    result: "{{ data | logical }}"
    # result == true


# Logical operators as conditions in if
- name: and as condition
  vars:
    data:
      if:
        and:
          - true
          - true
      then: and passed
      else: and failed
    result: "{{ data | logical }}"
    # result == "and passed"


- name: or as condition
  vars:
    data:
      if:
        or:
          - false
          - true
      then: or passed
      else: or failed
    result: "{{ data | logical }}"
    # result == "or passed"


- name: not as condition
  vars:
    data:
      if:
        not: false
      then: not passed
      else: not failed
    result: "{{ data | logical }}"
    # result == "not passed"


# Nested operators in condition
- name: nested operators
  vars:
    data:
      if:
        and:
          - not: false
          - or:
              - false
              - true
          - xor:
              - true
              - false
      then: all passed
      else: something failed
    result: "{{ data | logical }}"
    # result == "all passed"

Return Values

Section titled “Return Values”

_raw

Section titled “_raw”

inputs after logic applied.

Authors

Section titled “Authors”