Arbitrary.stencil

{%  for type in types.all where type.name == "SourceryImports_Arbitrary" %}
{% for variable in type.variables %}
{% if variable|annotated:"testable" %}@testable {% else %}{% endif %}{% if variable|annotated:"preconcurrency" %}@preconcurrency {% else %}{% endif %}import {{ variable.name }}
{% endfor %}

{% endfor %}

{% macro checkError typeNameString %}{% if typeNameString == "Error" %}String{% else %}{{ typeNameString }}{% endif %}{% endmacro %}
{% macro iterateVariables variables %}
                {% for var in variables %}
                  {% if var.actualTypeName.name|hasPrefix:"UI" %}
                    {{ var.name }}: {{ var.actualTypeName.name }}(){% if not forloop.last %},{% endif %} 
                  {% elif var.isOptional %}
                    {{ var.name }}: $0.generate(using: Optional<{{ var.actualTypeName.unwrappedTypeName }}>.arbitrary.map { $0 }){% if not forloop.last %}, {% endif %}
                  {% elif var.isArray %}
                    {{ var.name }}: $0.generate(using: Array<{{ var.typeName.array.elementTypeName.name }}>.arbitrary.map { $0 }){% if not forloop.last %}, {% endif %}
                  {% elif var.isDictionary %}
                    {{ var.name }}: $0.generate(using: Dictionary<{{ var.typeName.dictionary.keyTypeName.name }}, {{ var.typeName.dictionary.valueTypeName.name }}>.arbitrary.map { $0 }){% if not forloop.last %}, {% endif %}
                  {% elif var.actualTypeName.name|contains:">" %}
                    {{ var.name }}: $0.generate(using: Arbitrary{{ var.actualTypeName.name }}.arbitrary.map { $0.get }){% if not forloop.last %}, {% endif %}
				  {% elif var.actualTypeName.name == "Error" %}
					{{ var.name }}: $0.generate(using: String.arbitrary){% if not forloop.last %}, {% endif %}
				  {% else %}
                    {{ var.name }}: $0.generate(){% if not forloop.last %}, {% endif %}
                  {% endif %}
                {% endfor %}
{% endmacro %}
{% macro caseOptional type case associatedValue %}Optional<{{ associatedValue.actualTypeName.unwrappedTypeName }}>.arbitrary.map { $0 }.map({{ type.name}}.{{ case.name }}){% if not forloop.last %},{% endif %}{% endmacro %}
{% macro caseArray type case associatedValue %}Array<{{ associatedValue.typeName.array.elementTypeName.name }}>.arbitrary.map { $0 }.map({{ type.name}}.{{ case.name }}){% if not forloop.last %},{% endif %}{% endmacro %}
{% macro caseDictionary type case associatedValue %}Dictionary<{{ associatedValue.typeName.dictionary.keyTypeName.name }}, {{ associatedValue.typeName.dictionary.valueTypeName.name }}>.arbitrary.map { $0 }.map({{ type.name}}.{{ case.name }}){% if not forloop.last %},{% endif %}{% endmacro %}
{% macro iterateCases cases pureTypeName optionalGenericParameter %}
        {% for case in cases %}
            {% if not case.hasAssociatedValue %}
            Gen.pure({{ pureTypeName }}{{ optionalGenericParameter }}.{{ case.name }}){% if not forloop.last %},{% endif %}
            {% elif case.associatedValues.count == 1 %}
              {% if case.associatedValues.first.actualTypeName.name|hasPrefix:"UI" %}
            Gen<{{ case.associatedValues.first.actualTypeName.name }}>.pure({{ case.associatedValues.first.actualTypeName.name }}()).map({{ type.name }}.{{ case.name }}){% if not forloop.last %},{% endif %}
              {% elif case.associatedValues.first.isOptional %}
            {% call caseOptional type case case.associatedValues.first %}
              {% elif case.associatedValues.first.isArray %}
            {% call caseArray type case case.associatedValues.first %}
              {% elif case.associatedValues.first.isDictionary %}
            {% call caseDictionary type case case.associatedValues.first %}
              {% else %}
            {% call checkError case.associatedValues.first.actualTypeName.name %}.arbitrary.map({{ type.name }}.{{ case.name }}){% if not forloop.last %},{% endif %}
              {% endif %}
            {% else %}
            GenZip.with(
              {% for assoVal in case.associatedValues %}
                {% if assoVal.actualTypeName.name|hasPrefix:"UI" %}
              Gen<{{ assoVal.actualTypeName.name }}>.pure({{ assoVal.actualTypeName.name }}()){% if not forloop.last %},{% endif %}
                {% elif case.associatedValues.first.isOptional %}
              {% call caseOptional type case assoVal %}
                {% elif case.associatedValues.first.isArray %}
              {% call caseArray type case assoVal %}
                {% elif case.associatedValues.first.isDictionary %}
              {% call caseDictionary type case assoVal %}
                {% else %}
              {% call checkError assoVal.actualTypeName.name %}.arbitrary{% if not forloop.last %},{% endif %}{% endif %}{% endfor %})
              .map({{ type.name}}.{{ case.name }}){% if not forloop.last %},{% endif %}
            {% endif %}
        {% endfor %}
{% endmacro %}

// MARK: - Arbitrary for structs and classes
{% for type in types.structs|annotated:"arbitrary" %}

{% if type.isGeneric %}
struct Arbitrary{{ type.name }}<T>: Arbitrary where T: Arbitrary{% if type.annotations.genericParameterProtocols %} & {{ type.annotations.genericParameterProtocols }}{% endif %} {
    let get: {{ type.name }}<T>
    init(_ get: {{ type.name }}<T>) {
        self.get = get
    }

    public static var arbitrary: Gen<Arbitrary{{ type.name }}<T>> {
        return Gen<{{ type.name }}<T>>
            .compose {
                {{ type.name }}<T>.init(
                {% call iterateVariables type.storedVariables %}
                )
            }
            .map(Arbitrary{{ type.name }}<T>.init)
    }
}
{% else %}
extension {{ type.name }}: {% if type|annotated:"retroactive" %}@retroactive {% else %}{% endif %}Arbitrary {
    public static var arbitrary: Gen<{{ type.name }}> {
        return Gen<{{ type.name }}>
            .compose {
                {{ type.name }}.init(
                {% call iterateVariables type.storedVariables %}
                )
        }
    }
}
{% endif %}
{% endfor %}

// MARK: - Arbitrary for enums
{% for type in types.enums|annotated:"arbitrary" %}

{% if type.isGeneric %}
struct Arbitrary{{ type.name }}<T>: Arbitrary where T: Arbitrary{% if type.annotations.genericParameterProtocols %} & {{ type.annotations.genericParameterProtocols }}{% endif %} {
    let get: {{ type.name }}<T>
    init(_ get: {{ type.name }}<T>) {
        self.get = get
    }

    public static var arbitrary: Gen<Arbitrary{{ type.name }}<T>> {
        return Gen<{{ type.name }}<T>>.one(of: [
        {% call iterateCases type.cases type.name "<T>" %}
        ]).map(Arbitrary{{ type.name }}<T>.init)
    }
}
{% else %}
extension {{ type.name }}: {% if type|annotated:"retroactive" %}@retroactive {% else %}{% endif %}Arbitrary {
    public static var arbitrary: Gen<{{ type.name}}> {
        return Gen<{{ type.name}}>.one(of: [
        {% call iterateCases type.cases type.name "" %}
        ])
    }
}
{% endif %}
{% endfor %}