gshell/gshell-core/src/main/java/org/apache/servicemix/kernel/gshell/core/config/CommandParser.java

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you 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.apache.servicemix.kernel.gshell.core.config;

import java.util.ArrayList;
import java.util.List;

import org.w3c.dom.Element;

import org.apache.geronimo.gshell.command.Alias;
import org.apache.geronimo.gshell.command.Link;
import org.apache.geronimo.gshell.wisdom.command.AliasImpl;
import org.apache.geronimo.gshell.wisdom.command.ConfigurableCommandCompleter;
import org.apache.geronimo.gshell.wisdom.command.LinkImpl;
import org.apache.geronimo.gshell.wisdom.registry.CommandLocationImpl;
import org.apache.servicemix.kernel.gshell.core.CommandBundle;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.BeanDefinitionStoreException;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.config.BeanDefinitionHolder;
import org.springframework.beans.factory.config.RuntimeBeanReference;
import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.GenericBeanDefinition;
import org.springframework.beans.factory.support.ManagedList;
import org.springframework.beans.factory.xml.AbstractBeanDefinitionParser;
import org.springframework.beans.factory.xml.BeanDefinitionParserDelegate;
import org.springframework.beans.factory.xml.ParserContext;
import org.springframework.util.StringUtils;
import org.springframework.util.xml.DomUtils;

public class CommandParser extends AbstractBeanDefinitionParser {

    public static final String ID = ID_ATTRIBUTE;

    public static final String DESCRIPTION = "description";

    public static final String PLUGIN_TEMPLATE = "pluginTemplate";

    public static final String ACTION = "action";

    public static final String ACTION_ID = "actionId";

    public static final String COMMAND_TEMPLATE_SUFFIX = "CommandTemplate";

    public static final String COMMAND_BUNDLE = "command-bundle";

    public static final String NAME = "name";

    public static final String LOCATION = "location";

    public static final String COMMANDS = "commands";

    public static final String COMMAND = "command";

    public static final String TYPE = "type";

    public static final String DOCUMENTER = "documenter";

    public static final String COMPLETER = "completer";

    public static final String COMPLETERS = "completers";

    public static final String BEAN = "bean";

    public static final String REF = "ref";

    public static final String NULL = "null";

    public static final String MESSAGE_SOURCE = "message-source";

    public static final String MESSAGES = "messages";

    public static final String PROTOTYPE = "prototype";

    public static final String ALIAS = "alias";

    public static final String ALIASES = "aliases";

    public static final String LINK = "link";

    public static final String LINKS = "links";

    public static final String TARGET = "target";

    @Override
    protected boolean shouldGenerateId() {
        return true;
    }

    @Override
    protected boolean shouldGenerateIdAsFallback() {
        return true;
    }

    protected AbstractBeanDefinition parseInternal(final Element element, final ParserContext context) {
        assert element != null;
        assert context != null;

        Builder builder = new Builder(context);
        BeanDefinitionBuilder plugin = builder.parseCommandBundle(element);
        return plugin.getBeanDefinition();
    }

    /**
     * Helper to deal with command type.
     */
    private enum CommandType
    {
        STATELESS,
        STATEFUL;

        public static CommandType parse(final String text) {
            assert text != null;

            return valueOf(text.toUpperCase());
        }

        public String getTemplateName() {
            return name().toLowerCase() + COMMAND_TEMPLATE_SUFFIX;
        }

        public void wire(final BeanDefinitionBuilder command, final BeanDefinitionHolder action) {
            assert command != null;
            assert action != null;

            switch (this) {
                case STATELESS:
                    command.addPropertyReference(ACTION, action.getBeanName());
                    break;

                case STATEFUL:
                    command.addPropertyValue(ACTION_ID, action.getBeanName());
                    break;
            }
        }
    }

    /**
     * Helper to build plugin related bean definitions.
     */
    private class Builder
    {
        private final Logger log = LoggerFactory.getLogger(getClass());

        private ParserContext context;

        public Builder(final ParserContext context) {
            assert context != null;

            this.context = context;
        }

        private String resolveId(final Element element, final BeanDefinition def) throws BeanDefinitionStoreException {
            assert element != null;
            assert def != null;

            if (shouldGenerateId()) {
                return context.getReaderContext().generateBeanName(def);
            }

            String id = element.getAttribute(ID_ATTRIBUTE);

            if (!StringUtils.hasText(id) && shouldGenerateIdAsFallback()) {
                id = context.getReaderContext().generateBeanName(def);
            }

            return id;
        }

        @SuppressWarnings({"unchecked"})
        private List<Element> getChildElements(final Element element, final String name) {
            assert element != null;
            assert name != null;

            return DomUtils.getChildElementsByTagName(element, name);
        }

        @SuppressWarnings({"unchecked"})
        private List<Element> getChildElements(final Element element, final String[] names) {
            assert element != null;
            assert names != null;

            return DomUtils.getChildElementsByTagName(element, names);
        }

        @SuppressWarnings({"unchecked"})
        private Element getChildElement(final Element element, final String name) {
            assert element != null;
            assert name != null;

            List<Element> elements = DomUtils.getChildElementsByTagName(element, name);
            if (elements != null && !elements.isEmpty()) {
                return elements.get(0);
            }
            return null;
        }

        private BeanDefinitionParserDelegate createBeanDefinitionParserDelegate(final Element element) {
            assert element != null;

            BeanDefinitionParserDelegate parser = new BeanDefinitionParserDelegate(context.getReaderContext());
            parser.initDefaults(element.getOwnerDocument().getDocumentElement());
            return parser;
        }

        private BeanDefinitionHolder parseBeanDefinitionElement(final Element element) {
            assert element != null;

            BeanDefinitionParserDelegate parser = createBeanDefinitionParserDelegate(element);
            return parser.parseBeanDefinitionElement(element);
        }

        private void parseAndApplyDescription(final Element element, final BeanDefinition def) {
            assert element != null;
            assert def != null;

            Element desc = getChildElement(element, DESCRIPTION);
            if (desc != null) {
                if (def instanceof AbstractBeanDefinition) {
                    ((AbstractBeanDefinition)def).setDescription(desc.getTextContent());
                }
            }
        }

        private void parseAndApplyDescription(final Element element, final BeanDefinitionBuilder builder) {
            assert element != null;
            assert builder != null;

            parseAndApplyDescription(element, builder.getRawBeanDefinition());
        }

        private BeanDefinitionHolder register(final BeanDefinitionHolder holder) {
            assert holder != null;

            registerBeanDefinition(holder, context.getRegistry());
            return holder;
        }

        private BeanDefinitionHolder register(final BeanDefinition def, final String id) {
            assert def != null;
            assert id != null;

            BeanDefinitionHolder holder = new BeanDefinitionHolder(def, id);
            return register(holder);
        }

        //
        // <gshell:command-bundle>
        //

        private BeanDefinitionBuilder parseCommandBundle(final Element element) {
            assert element != null;

            log.trace("Parse command bundle; element; {}", element);

            BeanDefinitionBuilder bundle = BeanDefinitionBuilder.rootBeanDefinition(CommandBundle.class);
            parseAndApplyDescription(element, bundle);

            //
            // TODO: Figure out how we can save the order of <gshell:command> and <gshell:link> so that 'help' displays them in the order they are defined
            //

            ManagedList commands = new ManagedList();
            commands.addAll(parseCommands(element));
            bundle.addPropertyValue(COMMANDS, commands);

            ManagedList links = new ManagedList();
            links.addAll(parseLinks(element));
            bundle.addPropertyValue(LINKS, links);

            ManagedList aliases = new ManagedList();
            aliases.addAll(parseAliases(element));
            bundle.addPropertyValue(ALIASES, aliases);

            return bundle;
        }

        //
        // <gshell:command>
        //

        private List<BeanDefinition> parseCommands(final Element element) {
            assert element != null;

            log.trace("Parse commands; element; {}", element);

            List<BeanDefinition> commands = new ArrayList<BeanDefinition>();

            List<Element> children = getChildElements(element, COMMAND);

            for (Element child : children) {
                BeanDefinitionBuilder command = parseCommand(child);
                commands.add(command.getBeanDefinition());
            }

            return commands;
        }

        private BeanDefinitionBuilder parseCommand(final Element element) {
            assert element != null;

            log.trace("Parse command; element; {}", element);

            CommandType type = CommandType.parse(element.getAttribute(TYPE));
            BeanDefinitionBuilder command = BeanDefinitionBuilder.childBeanDefinition(type.getTemplateName());
            parseAndApplyDescription(element, command);

            Element child;

            // Required children elements

            String name = element.getAttribute(NAME);
            BeanDefinition def = new GenericBeanDefinition();
            def.setBeanClassName(CommandLocationImpl.class.getName());
            def.getConstructorArgumentValues().addGenericArgumentValue(name);
            command.addPropertyValue(LOCATION, def);

            child = getChildElement(element, ACTION);
            BeanDefinitionHolder action = parseCommandAction(child);
            type.wire(command, action);

            // Optional children elements

            child = getChildElement(element, DOCUMENTER);
            if (child != null) {
                BeanDefinitionHolder holder = parseBeanDefinitionElement(child);
                command.addPropertyValue(DOCUMENTER, holder.getBeanDefinition());
            }

            child = getChildElement(element, COMPLETER);
            if (child != null) {
                BeanDefinitionHolder holder = parseBeanDefinitionElement(child);
                command.addPropertyValue(COMPLETER, holder.getBeanDefinition());
            }

            child = getChildElement(element, COMPLETERS);
            if (child != null) {
                BeanDefinitionBuilder completer = parseCommandCompleters(child);
                command.addPropertyValue(COMPLETER, completer.getBeanDefinition());
            }

            child = getChildElement(element, MESSAGE_SOURCE);
            if (child != null) {
                BeanDefinitionHolder holder = parseBeanDefinitionElement(child);
                command.addPropertyValue(MESSAGES, holder.getBeanDefinition());
            }

            //String id = resolveId(element, command.getBeanDefinition());
            //BeanDefinitionHolder holder = register(command.getBeanDefinition(), id);

            return command;
        }

        //
        // <gshell:completers>
        //

        private BeanDefinitionBuilder parseCommandCompleters(final Element element) {
            assert element != null;

            BeanDefinitionBuilder completer = BeanDefinitionBuilder.rootBeanDefinition(ConfigurableCommandCompleter.class);

            ManagedList completers = new ManagedList();

            List<Element> children = getChildElements(element, new String[] {BEAN, REF, NULL});

            for (Element child : children) {
                if (DomUtils.nodeNameEquals(child, BEAN)) {
                    BeanDefinitionHolder holder = parseBeanDefinitionElement(child);
                    // noinspection unchecked
                    completers.add(holder.getBeanDefinition());
                }
                else if (DomUtils.nodeNameEquals(child, REF)) {
                    BeanDefinitionParserDelegate parser = createBeanDefinitionParserDelegate(child);
                    RuntimeBeanReference ref = (RuntimeBeanReference) parser.parsePropertySubElement(child, completer.getRawBeanDefinition());
                    // noinspection unchecked
                    completers.add(ref);
                }
                else if (DomUtils.nodeNameEquals(child, NULL)) {
                    // noinspection unchecked
                    completers.add(null);
                }
            }

            completer.addConstructorArgValue(completers);

            return completer;
        }

        //
        // <gshell:action>
        //

        private BeanDefinitionHolder parseCommandAction(final Element element) {
            assert element != null;

            log.trace("Parse command action; element; {}", element);

            // Construct the action
            BeanDefinition action = parseBeanDefinitionElement(element).getBeanDefinition();

            // All actions are configured as prototypes
            action.setScope(PROTOTYPE);

            // Generate id and register the bean
            String id = resolveId(element, action);
            return register(action, id);
        }

        //
        // <gshell:link>
        //

        private List<Link> parseLinks(final Element element) {
            assert element != null;

            log.trace("Parse links; element; {}", element);

            List<Link> links = new ArrayList<Link>();

            List<Element> children = getChildElements(element, LINK);

            for (Element child : children) {
                String name = child.getAttribute(NAME);
                String target = child.getAttribute(TARGET);

                links.add(new LinkImpl(name, target));
            }

            return links;
        }

        //
        // <gshell:alias>
        //

        private List<Alias> parseAliases(final Element element) {
            assert element != null;

            log.trace("Parse aliases; element; {}", element);

            List<Alias> aliases = new ArrayList<Alias>();

            List<Element> children = getChildElements(element, ALIAS);

            for (Element child : children) {
                String name = child.getAttribute(NAME);
                String alias = child.getAttribute(ALIAS);

                aliases.add(new AliasImpl(name, alias));
            }

            return aliases;
        }
    }
}