Example usage for org.apache.commons.lang StringUtils substringBeforeLast

Introduction

In this page you can find the example usage for org.apache.commons.lang StringUtils substringBeforeLast.

Prototype

public static String substringBeforeLast(String str, String separator)

Source Link

Document

Gets the substring before the last occurrence of a separator.

Usage

From source file:org.gradle.api.internal.project.AbstractProject.java

public Task findTask(String path) {
    if (!GUtil.isTrue(path)) {
        throw new InvalidUserDataException("A path must be specified!");
    }/*from w ww  .j a va  2s  . c  o  m*/
    if (!path.contains(PATH_SEPARATOR)) {
        return taskEngine.findTask(path);
    }

    String projectPath = StringUtils.substringBeforeLast(path, PATH_SEPARATOR);
    Project project = findProject(!GUtil.isTrue(projectPath) ? PATH_SEPARATOR : projectPath);
    if (project == null) {
        return null;
    }
    return project.task(StringUtils.substringAfterLast(path, PATH_SEPARATOR));
}

From source file:org.gradle.api.internal.resolve.LibraryPublishArtifact.java

private static String determineName(File file) {
    return StringUtils.substringBeforeLast(file.getName(), ".");
}

From source file:org.gradle.api.internal.tasks.DefaultTaskContainer.java

public Task findByPath(String path) {
    if (!GUtil.isTrue(path)) {
        throw new InvalidUserDataException("A path must be specified!");
    }//from w ww.  ja va 2s  .c  o  m
    if (!path.contains(Project.PATH_SEPARATOR)) {
        return findByName(path);
    }

    String projectPath = StringUtils.substringBeforeLast(path, Project.PATH_SEPARATOR);
    ProjectInternal project = this.project
            .findProject(!GUtil.isTrue(projectPath) ? Project.PATH_SEPARATOR : projectPath);
    if (project == null) {
        return null;
    }
    projectAccessListener.beforeRequestingTaskByPath(project);

    return project.getTasks().findByName(StringUtils.substringAfterLast(path, Project.PATH_SEPARATOR));
}

From source file:org.gradle.api.internal.tasks.testing.junit.report.AllTestResults.java

private PackageTestResults addPackageForClass(String className) {
    String packageName = StringUtils.substringBeforeLast(className, ".");
    if (packageName.equals(className)) {
        packageName = "";
    }//from w ww  . j a v  a  2s .c o m
    return addPackage(packageName);
}

From source file:org.gradle.build.docs.dsl.JavadocLinkConverter.java

private String doResolve(String link, ClassMetaData classMetaData) {
    if (link.contains(".")) {
        return link;
    }/*  ww  w . j av a  2  s .  co  m*/

    for (String importedClass : classMetaData.getImports()) {
        String baseName = StringUtils.substringAfterLast(importedClass, ".");
        if (baseName.equals("*")) {
            String candidateClassName = StringUtils.substringBeforeLast(importedClass, ".") + "." + link;
            if (metaDataRepository.findClass(candidateClassName) != null) {
                return candidateClassName;
            }
        } else if (link.equals(baseName)) {
            return importedClass;
        }
    }

    String candidateClassName = StringUtils.substringBeforeLast(classMetaData.getClassName(), ".") + "." + link;
    if (metaDataRepository.findClass(candidateClassName) != null) {
        return candidateClassName;
    }

    return null;
}

From source file:org.gradle.build.docs.dsl.model.ClassMetaData.java

public ClassMetaData(String className) {
    this(className, StringUtils.substringBeforeLast(className, "."), false, false, "");
}

From source file:org.gradle.execution.ProjectFinderByTaskPath.java

public ProjectInternal findProject(String taskPath, ProjectInternal startFrom) {
    if (!taskPath.contains(Project.PATH_SEPARATOR)) {
        throw new IllegalArgumentException(
                "I can only find tasks based on a task path (e.g. containing ':'). However, '" + taskPath
                        + "' was passed.");
    }/*w  ww .  j a  v a  2s . c o m*/
    String projectPath = StringUtils.substringBeforeLast(taskPath, Project.PATH_SEPARATOR);
    projectPath = projectPath.length() == 0 ? Project.PATH_SEPARATOR : projectPath;
    return findProjectNow(projectPath, startFrom);
}

From source file:org.gradle.execution.TaskNameDrivenProjectEvaluator.java

public void configure(BuildExecutionContext context) {
    if (!context.getGradle().getStartParameter().isConfigureOnDemand()) {
        context.proceed();/*from  w  ww . j  av  a  2 s.  co  m*/
        return;
    }

    List<String> taskNames = context.getGradle().getStartParameter().getTaskNames();
    ProjectInternal project = context.getGradle().getDefaultProject();

    //TODO SF most below is copied over from the TaskSelector - it needs refactoring, coverage, etc.
    //Probably this action should be only configured when configuration on demand is 'on'
    for (String path : taskNames) {
        if (path.contains(Project.PATH_SEPARATOR)) {
            String projectPath = StringUtils.substringBeforeLast(path, Project.PATH_SEPARATOR);
            projectPath = projectPath.length() == 0 ? Project.PATH_SEPARATOR : projectPath;
            project = findProject(project, projectPath);
            project.evaluate();
        } else {
            project.evaluate();
            for (Project sub : project.getSubprojects()) {
                ((ProjectInternal) sub).evaluate();
            }
        }
    }
    context.proceed();
}

From source file:org.gradle.execution.TaskNameResolvingBuildExecuter.java

private static Map<String, Collection<Task>> doSelect(GradleInternal gradle, Iterable<String> paths) {
    Project defaultProject = gradle.getDefaultProject();

    Map<String, Collection<Task>> allProjectsTasksByName = null;

    Map<String, Collection<Task>> matches = new LinkedHashMap<String, Collection<Task>>();
    for (String path : paths) {
        Map<String, Collection<Task>> tasksByName;
        String baseName;/*from w  ww  . j  a  v  a 2s .c om*/
        String prefix;

        if (path.contains(Project.PATH_SEPARATOR)) {
            prefix = StringUtils.substringBeforeLast(path, Project.PATH_SEPARATOR);
            prefix = prefix.length() == 0 ? Project.PATH_SEPARATOR : prefix;
            Project project = defaultProject.findProject(prefix);
            if (project == null) {
                throw new TaskSelectionException(
                        String.format("Project '%s' not found in %s.", prefix, defaultProject));
            }
            baseName = StringUtils.substringAfterLast(path, Project.PATH_SEPARATOR);
            Task match = project.getTasks().findByName(baseName);
            if (match != null) {
                matches.put(path, Collections.singleton(match));
                continue;
            }

            tasksByName = new HashMap<String, Collection<Task>>();
            for (Task task : project.getTasks().getAll()) {
                tasksByName.put(task.getName(), Collections.singleton(task));
            }
            prefix = prefix + Project.PATH_SEPARATOR;

        } else {
            Set<Task> tasks = defaultProject.getTasksByName(path, true);
            if (!tasks.isEmpty()) {
                matches.put(path, tasks);
                continue;
            }
            if (allProjectsTasksByName == null) {
                allProjectsTasksByName = buildTaskMap(defaultProject);
            }
            tasksByName = allProjectsTasksByName;
            baseName = path;
            prefix = "";
        }

        Pattern pattern = getPatternForName(baseName);
        Set<String> patternCandidates = new TreeSet<String>();
        Set<String> typoCandidates = new TreeSet<String>();
        for (String candidate : tasksByName.keySet()) {
            if (pattern.matcher(candidate).matches()) {
                patternCandidates.add(candidate);
            }
            if (StringUtils.getLevenshteinDistance(baseName.toUpperCase(), candidate.toUpperCase()) <= Math
                    .min(3, baseName.length() / 2)) {
                typoCandidates.add(candidate);
            }
        }
        if (patternCandidates.size() == 1) {
            String actualName = patternCandidates.iterator().next();
            matches.put(prefix + actualName, tasksByName.get(actualName));
            continue;
        }

        if (!patternCandidates.isEmpty()) {
            throw new TaskSelectionException(String.format("Task '%s' is ambiguous in %s. Candidates are: %s.",
                    baseName, defaultProject, GUtil.toString(patternCandidates)));
        }
        if (!typoCandidates.isEmpty()) {
            throw new TaskSelectionException(
                    String.format("Task '%s' not found in %s. Some candidates are: %s.", baseName,
                            defaultProject, GUtil.toString(typoCandidates)));
        }
        throw new TaskSelectionException(String.format("Task '%s' not found in %s.", baseName, defaultProject));
    }

    return matches;
}

From source file:org.gradle.execution.TaskSelector.java

public void selectTasks(GradleInternal gradle, String path) {
    SetMultimap<String, Task> tasksByName;
    String baseName;//from w ww. j a  v a 2 s. c om
    String prefix;

    ProjectInternal project = gradle.getDefaultProject();

    if (path.contains(Project.PATH_SEPARATOR)) {
        String projectPath = StringUtils.substringBeforeLast(path, Project.PATH_SEPARATOR);
        projectPath = projectPath.length() == 0 ? Project.PATH_SEPARATOR : projectPath;
        project = findProject(project, projectPath);
        baseName = StringUtils.substringAfterLast(path, Project.PATH_SEPARATOR);
        prefix = project.getPath() + Project.PATH_SEPARATOR;

        tasksByName = taskNameResolver.select(baseName, project);
    } else {
        baseName = path;
        prefix = "";

        tasksByName = taskNameResolver.selectAll(path, project);
    }

    Set<Task> tasks = tasksByName.get(baseName);
    if (!tasks.isEmpty()) {
        // An exact match
        this.tasks = tasks;
        this.taskName = path;
        return;
    }

    NameMatcher matcher = new NameMatcher();
    String actualName = matcher.find(baseName, tasksByName.keySet());

    if (actualName != null) {
        // A partial match
        this.tasks = tasksByName.get(actualName);
        this.taskName = prefix + actualName;
        return;
    }

    throw new TaskSelectionException(matcher.formatErrorMessage("task", project));
}