org.openrewrite.yaml.ChangePropertyKey Maven / Gradle / Ivy

Go to download
/*
 * Copyright 2020 the original author or authors.
 * 
 * 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
 * 

 * https://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.openrewrite.yaml;

import org.openrewrite.Formatting;
import org.openrewrite.Validated;
import org.openrewrite.yaml.tree.Yaml;

import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import static java.util.Spliterators.spliteratorUnknownSize;
import static java.util.stream.Collectors.toList;
import static java.util.stream.StreamSupport.stream;
import static org.openrewrite.Formatting.formatFirstPrefix;
import static org.openrewrite.Tree.randomId;
import static org.openrewrite.Validated.required;

/**
 * When nested YAML mappings are interpreted as dot
 * separated property names, e.g. as Spring Boot
 * interprets application.yml files.
 */
public class ChangePropertyKey extends YamlRefactorVisitor {
    private String property;
    private String toProperty;
    private boolean coalesce = true;

    public ChangePropertyKey() {
        setCursoringOn();
    }

    public void setProperty(String property) {
        this.property = property;
    }

    public void setToProperty(String toProperty) {
        this.toProperty = toProperty;
    }

    public void setCoalesce(boolean coalesce) {
        this.coalesce = coalesce;
    }

    @Override
    public Validated validate() {
        return required("property", property)
                .and(required("toProperty", toProperty));
    }

    @Override
    public boolean isIdempotent() {
        return false;
    }

    @Override
    public Yaml visitMappingEntry(Yaml.Mapping.Entry entry) {
        Yaml.Mapping.Entry e = refactor(entry, super::visitMappingEntry);

        Deque propertyEntries = getCursor().getPathAsStream()
                .filter(Yaml.Mapping.Entry.class::isInstance)
                .map(Yaml.Mapping.Entry.class::cast)
                .collect(Collectors.toCollection(ArrayDeque::new));

        String property = stream(spliteratorUnknownSize(propertyEntries.descendingIterator(), 0), false)
                .map(e2 -> e2.getKey().getValue())
                .collect(Collectors.joining("."));

        String propertyToTest = this.toProperty;
        if (property.equals(this.property)) {
            Iterator propertyEntriesLeftToRight = propertyEntries.descendingIterator();
            while (propertyEntriesLeftToRight.hasNext()) {
                Yaml.Mapping.Entry propertyEntry = propertyEntriesLeftToRight.next();
                String value = propertyEntry.getKey().getValue();

                if (!propertyToTest.startsWith(value)) {
                    andThen(new InsertSubproperty(
                            propertyEntry,
                            propertyToTest,
                            entry.getValue()
                    ));
                    andThen(new DeleteProperty(entry));
                    if (coalesce) {
                        maybeCoalesceProperties();
                    }
                    break;
                }

                propertyToTest = propertyToTest.substring(value.length() + 1);
            }
        }

        return e;
    }

    private static class InsertSubproperty extends YamlRefactorVisitor {
        private final Yaml.Mapping.Entry scope;
        private final String subproperty;
        private final Yaml.Block value;

        private InsertSubproperty(Yaml.Mapping.Entry scope, String subproperty, Yaml.Block value) {
            this.scope = scope;
            this.subproperty = subproperty;
            this.value = value;
        }

        @Override
        public Yaml visitMapping(Yaml.Mapping mapping) {
            Yaml.Mapping m = refactor(mapping, super::visitMapping);

            if (m.getEntries().contains(scope)) {
                Formatting newEntryFormatting = scope.getFormatting();
                if (newEntryFormatting.getPrefix().isEmpty()) {
                    newEntryFormatting = newEntryFormatting.withPrefix("\n");
                }

                m = m.withEntries(Stream.concat(
                        m.getEntries().stream(),
                        Stream.of(
                                new Yaml.Mapping.Entry(randomId(),
                                        new Yaml.Scalar(randomId(), Yaml.Scalar.Style.PLAIN, subproperty,
                                                Formatting.EMPTY),
                                        value.copyPaste(),
                                        newEntryFormatting
                                )
                        )
                ).collect(toList()));
            }

            return m;
        }
    }

    private static class DeleteProperty extends YamlRefactorVisitor {
        private final Yaml.Mapping.Entry scope;

        private DeleteProperty(Yaml.Mapping.Entry scope) {
            this.scope = scope;
            setCursoringOn();
        }

        @Override
        public Yaml visitMapping(Yaml.Mapping mapping) {
            Yaml.Mapping m = refactor(mapping, super::visitMapping);

            boolean changed = false;
            List entries = new ArrayList<>();
            for (Yaml.Mapping.Entry entry : m.getEntries()) {
                if (entry == scope || (entry.getValue() instanceof Yaml.Mapping && ((Yaml.Mapping) entry.getValue()).getEntries().isEmpty())) {
                    changed = true;
                } else {
                    entries.add(entry);
                }
            }

            if (changed) {
                m = m.withEntries(entries);

                if (getCursor().getParentOrThrow().getTree() instanceof Yaml.Document) {
                    Yaml.Document document = getCursor().getParentOrThrow().getTree();
                    if (!document.isExplicit()) {
                        m = m.withEntries(formatFirstPrefix(m.getEntries(), ""));
                    }
                }
            }

            return m;
        }
    }
}