org.aesh.command.map.MapProcessedCommandBuilder Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of aesh
Æsh (Another Extendable SHell)
The newest version!
/*
 * JBoss, Home of Professional Open Source
 * Copyright 2016 Red Hat Inc. and/or its affiliates and other contributors
 * as indicated by the @authors tag. All rights reserved.
 * See the copyright.txt in the distribution for a
 * full listing of individual contributors.
 *
 * 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.aesh.command.map;

import java.util.ArrayList;
import java.util.Collections;

import org.aesh.command.activator.CommandActivator;
import org.aesh.command.impl.internal.ProcessedOption;
import org.aesh.command.invocation.CommandInvocation;
import org.aesh.command.populator.CommandPopulator;
import org.aesh.command.impl.result.NullResultHandler;
import org.aesh.command.result.ResultHandler;
import org.aesh.command.validator.CommandValidator;
import org.aesh.command.impl.validator.NullCommandValidator;
import org.aesh.util.ReflectionUtil;
import org.aesh.command.parser.CommandLineParserException;
import java.util.List;

public class MapProcessedCommandBuilder {

    private MapProcessedOptionProvider provider;
    private String name;
    private String description;
    private CommandValidator,CI> validator;
    private ResultHandler resultHandler;
    private ProcessedOption arguments;
    private ProcessedOption argument;
    private final List options;
    private CommandPopulator populator;
    private MapCommand command;
    private List aliases;
    private CommandActivator activator;
    private boolean lookup;
    private boolean generateHelp;
    private boolean disableParsing;
    private String version;

    private MapProcessedCommandBuilder() {
        options = new ArrayList<>();
    }

    public static  MapProcessedCommandBuilder builder() {
        return new MapProcessedCommandBuilder<>();
    }

    public MapProcessedCommandBuilder lookupAtCompletionOnly(boolean lookup) {
        this.lookup = lookup;
        return this;
    }

    public MapProcessedCommandBuilder name(String name) {
        this.name = name;
        return this;
    }

    public MapProcessedCommandBuilder name(List aliases) {
        this.aliases = aliases == null ? Collections.emptyList()
                : Collections.unmodifiableList(aliases);
        return this;
    }

    public MapProcessedCommandBuilder description(String usage) {
        this.description = usage;
        return this;
    }

    public MapProcessedCommandBuilder version(String version) {
        this.version = version;
        return this;
    }

    public MapProcessedCommandBuilder generateHelp(boolean help) {
        this.generateHelp = help;
        return this;
    }

    public MapProcessedCommandBuilder disableParsing(boolean disableParsing) {
        this.disableParsing = disableParsing;
        return this;
    }

    public MapProcessedCommandBuilder optionProvider(MapProcessedOptionProvider provider) {
        this.provider = provider;
        return this;
    }

    public MapProcessedCommandBuilder arguments(ProcessedOption arguments) {
        this.arguments = arguments;
        return this;
    }

    public MapProcessedCommandBuilder argument(ProcessedOption argument) {
        this.argument = argument;
        return this;
    }

    public MapProcessedCommandBuilder validator(CommandValidator,CI> validator) {
        this.validator = validator;
        return this;
    }

    @SuppressWarnings("unchecked")
    public MapProcessedCommandBuilder validator(Class validator) {
        this.validator = initValidator(validator);
        return this;
    }

    private CommandValidator initValidator(Class validator) {
        if (validator != null && !validator.equals(NullCommandValidator.class)) {
            return ReflectionUtil.newInstance(validator);
        } else {
            return new NullCommandValidator();
        }
    }

    public MapProcessedCommandBuilder resultHandler(Class resultHandler) {
        this.resultHandler = initResultHandler(resultHandler);
        return this;
    }

    private ResultHandler initResultHandler(Class resultHandler) {
        if (resultHandler != null && !resultHandler.equals(NullResultHandler.class)) {
            return ReflectionUtil.newInstance(resultHandler);
        } else {
            return new NullResultHandler();
        }
    }

    public MapProcessedCommandBuilder resultHandler(ResultHandler resultHandler) {
        this.resultHandler = resultHandler;
        return this;
    }

    /**
     * By default a map populator will inject values in the MapCommand
     *
     * @param populator
     * @return
     */
    public MapProcessedCommandBuilder populator(CommandPopulator populator) {
        this.populator = populator;
        return this;
    }

    public MapProcessedCommandBuilder command(MapCommand command) {
        this.command = command;
        return this;
    }

    public MapProcessedCommandBuilder command(Class> command) {
        this.command = ReflectionUtil.newInstance(command);
        return this;
    }

    public MapProcessedCommandBuilder addOption(ProcessedOption option) {
        this.options.add(option);
        return this;
    }

    public MapProcessedCommandBuilder addOptions(List options) {
        if (options != null) {
            this.options.addAll(options);
        }
        return this;
    }

    public MapProcessedCommandBuilder activator(CommandActivator activator) {
        this.activator = activator;
        return this;
    }

    @SuppressWarnings("unchecked")
    public MapProcessedCommand create() throws CommandLineParserException {
        if (name == null || name.length() < 1) {
            throw new CommandLineParserException("The parameter name must be defined");
        }

        if (validator == null) {
            validator = (CommandValidator) new NullCommandValidator();
        }

        if (resultHandler == null) {
            resultHandler = new NullResultHandler();
        }

        if (populator == null) {
            populator = new MapCommandPopulator<>(command);
        }

        return new MapProcessedCommand<>(name,
                aliases,
                command,
                description,
                validator,
                resultHandler,
                generateHelp,
                disableParsing,
                version,
                arguments,
                options,
                argument,
                populator,
                provider,
                activator,
                lookup);
    }
}