Produits Entr'ouvert » Passerelle

        return mark_safe(s)

    def html_type(s):

        return '<span class="type">%s</span>' % s

    if 'anyOf' in schema:

        return many_of('anyOf', schema['anyOf'])

        return many_of('oneOf', schema['oneOf'])

    if 'allOf' in schema:

        return many_of('allOf', schema['allOf'])

    original_schema = schema

    schema = schema.copy()

    schema.pop('$schema', None)

    if typ == 'object':

        s = html_type('object')

        unflatten = schema.pop('unflatten', False)

        merge_extra = schema.pop('merge_extra', False)

        properties = schema.pop('properties', {})

        pattern_properties = schema.pop('patternProperties', {})

        required_keys = schema.pop('required', [])

        additional_properties = schema.pop('additionalProperties', True)

        if unflatten:

            s += format_html(', <em class="unflatten">{}</em>', _('unflatten'))

        if merge_extra:

            s += format_html(', <em class="merge-extra">{}</em>', _('merge extra'))

        if not additional_properties:

            s += format_html(

                ', <em class="additional-properties-false">{}</em>', _('no additional properties')

            )

        if properties:

            keys = properties

            if not isinstance(properties, collections.OrderedDict):

                keys = sorted(properties, key=lambda key: key.lower())

            for key in keys:

                sub = properties.get(key, {}).copy()

                render_property_schema(format_html('<tt>{0}</tt>', key), sub)

        if pattern_properties:

            s += format_html('<li><span>{0}</span>', _('Pattern properties'))

            s += '\n<ul>'

            for key, sub in pattern_properties.items():

                if key:

                    pattern_key = format_html('/<tt>{0}</tt>/', key)

                else:

        return mark_safe(s)

    if typ == 'boolean':

        if not schema:

            return mark_safe(html_type('boolean'))

    enum = schema.pop('enum', [])

    if enum and not schema:

        return mark_safe(' | '.join([format_html('<tt>{}</tt>', json.dumps(el)) for el in enum]))

    return format_html('<em>{0} {1!r}</em>', _('unknown validation'), original_schema)

@register.simple_tag(takes_context=False)

def render_body_schemas(body_schemas):

    if not body_schemas:

        return ''

def test_render_pattern_description():

    schema = {'type': 'object', 'properties': {'filename': {'type': 'string', 'pattern': 'abc'}}}

    assert 'abc' in render_json_schema(schema)

    schema['properties']['filename']['pattern_description'] = 'efg'

    assert 'abc' not in render_json_schema(schema) and 'efg' in render_json_schema(schema)