Package org.raml.emitter

Source Code of org.raml.emitter.RamlEmitter

/*
* Copyright 2013 (c) MuleSoft, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*   http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
* either express or implied. See the License for the specific
* language governing permissions and limitations under the License.
*/
package org.raml.emitter;

import static org.apache.commons.lang.StringUtils.isNotEmpty;
import static org.raml.parser.utils.ReflectionUtils.isEnum;
import static org.raml.parser.utils.ReflectionUtils.isPojo;

import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.math.BigDecimal;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.regex.Pattern;

import org.apache.commons.lang.StringUtils;
import org.raml.model.Protocol;
import org.raml.model.Raml;
import org.raml.model.SecurityReference;
import org.raml.model.parameter.AbstractParam;
import org.raml.parser.annotation.Mapping;
import org.raml.parser.annotation.Scalar;
import org.raml.parser.annotation.Sequence;
import org.raml.parser.utils.ReflectionUtils;

public class RamlEmitter
{

    public static final String VERSION = "#%RAML 0.8";
    private static final String INDENTATION = "    ";
    private static final String YAML_SEQ = "- ";
    private static final String YAML_SEQ_START = "[";
    private static final String YAML_SEQ_END = "]";
    private static final String YAML_SEQ_SEP = ", ";
    private static final String YAML_MAP_SEP = ": ";

    private static final Pattern NO_QUOTES = Pattern.compile("^[a-zA-Z_/+][^:]*$");
    private static final String[] LITERALS = {"yes", "no", "true", "false", "on", "off", "null"};

    public String dump(Raml raml)
    {
        StringBuilder dump = new StringBuilder(VERSION);
        dump.append("\n");
        int depth = 0;
        dumpPojo(dump, depth, raml);
        return dump.toString();
    }

    private void dumpPojo(StringBuilder dump, int depth, Object pojo)
    {
        final List<Field> declaredFields = ReflectionUtils.getInheritedFields(pojo.getClass());
        pojo.getClass();
        for (Field declaredField : declaredFields)
        {
            declaredField.setAccessible(true);
            Scalar scalar = declaredField.getAnnotation(Scalar.class);
            Mapping mapping = declaredField.getAnnotation(Mapping.class);
            Sequence sequence = declaredField.getAnnotation(Sequence.class);

            if (scalar != null)
            {
                dumpScalarField(dump, depth, declaredField, pojo);
            }
            else if (mapping != null)
            {
                dumpMappingField(dump, depth, declaredField, mapping.implicit(), pojo);
            }
            else if (sequence != null)
            {
                dumpSequenceField(dump, depth, declaredField, pojo);
            }
        }
    }

    private Object getFieldValue(Field field, Object pojo)
    {
        try
        {
            return field.get(pojo);
        }
        catch (IllegalAccessException e)
        {
            throw new RuntimeException(e);
        }
    }

    private void dumpSequenceField(StringBuilder dump, int depth, Field field, Object pojo)
    {
        if (!List.class.isAssignableFrom(field.getType()))
        {
            throw new RuntimeException("Only List can be sequence.");
        }

        List seq = (List) getFieldValue(field, pojo);
        if (seq == null || seq.size() == 0)
        {
            return;
        }

        Type type = field.getGenericType();
        if (type instanceof ParameterizedType)
        {
            ParameterizedType pType = (ParameterizedType) type;
            Type itemType = pType.getActualTypeArguments()[0];
            dump.append(indent(depth)).append(alias(field)).append(YAML_MAP_SEP);
            dumpSequenceItems(dump, depth, seq, itemType);
        }
    }

    private void dumpSequenceItems(StringBuilder dump, int depth, List seq, Type itemType)
    {
        if (itemType instanceof ParameterizedType)
        {
            generateSequenceOfMaps(dump, depth + 1, seq, (ParameterizedType) itemType);
            return;
        }
        if (customSequenceHandled(dump, depth + 1, seq, itemType))
        {
            return;
        }
        if (isPojo((Class<?>) itemType))
        {
            dump.append("\n");
            for (Object item : seq)
            {
                dump.append(indent(depth + 1)).append(YAML_SEQ).append("\n");
                dumpPojo(dump, depth + 2, item);
            }
        }
        else
        {
            generateInlineSequence(dump, seq);
        }
    }

    private boolean customSequenceHandled(StringBuilder dump, int depth, List seq, Type itemType)
    {
        if ((itemType instanceof Class<?>) && SecurityReference.class.isAssignableFrom((Class<?>) itemType))
        {
            handleSecurityReference(dump, depth, seq);
        }
        else if ((itemType instanceof Class<?>) && AbstractParam.class.isAssignableFrom((Class<?>) itemType) && seq.size() == 1)
        {
            handleSingleParameterAsNoSeq(dump, depth, seq);
        }
        else
        {
            return false;
        }
        return true;
    }

    private void handleSingleParameterAsNoSeq(StringBuilder dump, int depth, List seq)
    {
        dump.append("\n");
        dumpPojo(dump, depth, seq.get(0));
    }

    private void handleSecurityReference(StringBuilder dump, int depth, List seq)
    {
        dump.append("\n");
        for (Object item : seq)
        {
            dump.append(indent(depth)).append(YAML_SEQ).append("\n");
            dump.append(indent(depth + 1)).append(((SecurityReference) item).getName());
            if (((SecurityReference) item).getParameters().size() > 0)
            {
                dump.append(YAML_MAP_SEP).append("\n");
                dumpMap(dump, depth + 2, String.class, ((SecurityReference) item).getParameters());
            }
            else
            {
                dump.append("\n");
            }
        }
    }

    private void generateSequenceOfMaps(StringBuilder dump, int depth, List seq, ParameterizedType itemType)
    {
        Type rawType = itemType.getRawType();
        if (rawType instanceof Class && Map.class.isAssignableFrom((Class<?>) rawType))
        {
            Type valueType = itemType.getActualTypeArguments()[1];
            if (valueType instanceof Class)
            {
                dump.append("\n");
                for (Object item : seq)
                {
                    dump.append(indent(depth)).append(YAML_SEQ).append("\n");
                    dumpMap(dump, depth + 1, valueType, (Map) item);
                }
            }
        }
    }

    private void generateInlineSequence(StringBuilder dump, List seq)
    {
        dump.append(YAML_SEQ_START);
        for (int i = 0; i < seq.size(); i++)
        {
            Object item = seq.get(i);
            dump.append(sanitizeScalarValue(0, item));
            if (i < seq.size() - 1)
            {
                dump.append(YAML_SEQ_SEP);
            }
        }
        dump.append(YAML_SEQ_END).append("\n");
    }

    private void dumpMappingField(StringBuilder dump, int depth, Field field, boolean implicit, Object pojo)
    {
        if (!Map.class.isAssignableFrom(field.getType()))
        {
            throw new RuntimeException("invalid type");
        }

        Map value = (Map) getFieldValue(field, pojo);

        if (value == null || value.isEmpty())
        {
            return;
        }

        if (!implicit)
        {
            dump.append(indent(depth)).append(alias(field)).append(YAML_MAP_SEP).append("\n");
            depth++;
        }

        ParameterizedType pType = (ParameterizedType) field.getGenericType();
        Type valueType = pType.getActualTypeArguments()[1];
        dumpMap(dump, depth, valueType, value);
    }

    private void dumpMap(StringBuilder dump, int depth, Type valueType, Map value)
    {
        Type listType = null;
        if (valueType instanceof ParameterizedType)
        {
            Type rawType = ((ParameterizedType) valueType).getRawType();
            if (rawType instanceof Class && List.class.isAssignableFrom((Class<?>) rawType))
            {
                listType = ((ParameterizedType) valueType).getActualTypeArguments()[0];
            }
        }

        //body
        for (Map.Entry entry : (Set<Map.Entry>) value.entrySet())
        {
            dump.append(indent(depth)).append(sanitizeScalarValue(depth, entry.getKey()));
            dump.append(YAML_MAP_SEP);

            if (listType != null)
            {
                dumpSequenceItems(dump, depth, (List) entry.getValue(), listType);
            }
            else if (isPojo((Class<?>) valueType))
            {
                dump.append("\n");
                dumpPojo(dump, depth + 1, entry.getValue());
            }
            else //scalar
            {
                dump.append(sanitizeScalarValue(depth + 1, entry.getValue())).append("\n");
            }
        }

    }

    private void dumpScalarField(StringBuilder dump, int depth, Field field, Object pojo)
    {
        try
        {
            Object value = field.get(pojo);
            if (value == null)
            {
                return;
            }
            dump.append(indent(depth)).append(alias(field)).append(YAML_MAP_SEP);
            if (isPojo(value.getClass()))
            {
                dump.append("\n");
                dumpPojo(dump, depth + 1, value);
            }
            else
            {
                dump.append(sanitizeScalarValue(depth, value)).append("\n");
            }
        }
        catch (IllegalAccessException e)
        {
            throw new RuntimeException(e);
        }
    }

    private String alias(Field field)
    {
        Scalar scalar = field.getAnnotation(Scalar.class);
        Mapping mapping = field.getAnnotation(Mapping.class);
        Sequence sequence = field.getAnnotation(Sequence.class);

        if (scalar != null && isNotEmpty(scalar.alias()))
        {
            return scalar.alias();
        }
        else if (mapping != null && isNotEmpty(mapping.alias()))
        {
            return mapping.alias();
        }
        else if (sequence != null && isNotEmpty(sequence.alias()))
        {
            return sequence.alias();
        }
        return field.getName();
    }

    private String sanitizeScalarValue(int depth, Object value)
    {
        Class<?> type = value.getClass();
        String result = handleCustomScalar(value);
        if (result != null)
        {
            return result;
        }
        if (isEnum(type))
        {
            result = String.valueOf(value).toLowerCase();
        }
        else if (String.class.isAssignableFrom(type))
        {
            String text = (String) value;
            if (text.contains("\n") || text.contains("\\"))
            {
                result = blockFormat(depth, text);
            }
            else
            {
                result = inlineFormat(depth, text);
            }
        }
        else
        {
            result = String.valueOf(value);
        }
        return result;
    }

    private String handleCustomScalar(Object value)
    {
        if (value instanceof Protocol)
        {
            return String.valueOf(value);
        }
        if (value instanceof BigDecimal)
        {
            return ((BigDecimal) value).stripTrailingZeros().toString();
        }
        return null;
    }

    private String inlineFormat(int depth, String text)
    {
        if (!requiresQuoting(text))
        {
            return text;
        }
        if (!text.contains("\""))
        {
            return "\"" + text + "\"";
        }
        if (!text.contains("'"))
        {
            return "'" + text + "'";
        }
        return blockFormat(depth, text);
    }

    private boolean requiresQuoting(String text)
    {
        return !NO_QUOTES.matcher(text).matches() ||
               isReserved(text);
    }

    private boolean isReserved(String text)
    {
        for (String literal : LITERALS)
        {
            if (literal.equalsIgnoreCase(text))
            {
                return true;
            }
        }
        return false;
    }

    private String blockFormat(int depth, String text)
    {
        StringBuilder block = new StringBuilder("|\n");
        String[] lines = text.split("\n");
        for (String line : lines)
        {
            block.append(indent(depth + 1)).append(line).append("\n");
        }
        return block.substring(0, block.length() - 1);
    }

    private String indent(int depth)
    {
        return StringUtils.repeat(INDENTATION, depth);
    }
}
TOP

Related Classes of org.raml.emitter.RamlEmitter

TOP
Copyright © 2018 www.massapi.com. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.