Examples with Action org.gradle.api.Action used on opensource projects

Example 1 with Action

use of org.gradle.api.Action in project atlas by alibaba.

the class PublishHooker method hookPublish.

public void hookPublish() {
    project.getTasks().whenTaskAdded(new Action<Task>() {

        @Override
        public void execute(Task task) {
            if ("publishMavenPublicationToMavenRepository".equals(task.getName())) {
                publishTask = (PublishToMavenRepository) task;
                task.setEnabled(false);
                if (null != hookTask) {
                    hookTask.setRepository(publishTask.getRepository());
                    hookTask.setPublication(publishTask.getPublication());
                }
            }
        }
    });
    final TaskContainer tasks = project.getTasks();
    Task publishLifecycleTask = tasks.getByName(PublishingPlugin.PUBLISH_LIFECYCLE_TASK_NAME);
    String taskName = "publishMavenPublicationToMavenRepositoryHook";
    hookTask = tasks.create(taskName, PublishToMavenRepositoryHook.class, new Action<PublishToMavenRepositoryHook>() {

        public void execute(PublishToMavenRepositoryHook publishTask) {
            publishTask.setGroup(PublishingPlugin.PUBLISH_TASK_GROUP);
        }
    });
    publishLifecycleTask.dependsOn(taskName);
}

Example 2 with Action

use of org.gradle.api.Action in project gradle by gradle.

the class MapFileTreeTest method containsWontCreateFiles.

@Test
public void containsWontCreateFiles() {
    final AtomicInteger callCounter = new AtomicInteger(0);
    Action<OutputStream> fileAction = new Action<OutputStream>() {

        @Override
        public void execute(OutputStream outputStream) {
            callCounter.incrementAndGet();
        }
    };
    tree.add("file.txt", fileAction);
    FileTreeAdapter fileTreeAdapter = new FileTreeAdapter(tree);
    File file = rootDir.file("file.txt");
    assertTrue(fileTreeAdapter.contains(file));
    assertTrue(fileTreeAdapter.contains(file));
    assertFalse(fileTreeAdapter.contains(rootDir.file("file2.txt")));
    assertEquals(0, callCounter.get());
}

Example 3 with Action

use of org.gradle.api.Action in project gradle by gradle.

the class TaskFactory method createTask.

public TaskInternal createTask(Map<String, ?> args) {
    Map<String, Object> actualArgs = new HashMap<String, Object>(args);
    checkTaskArgsAndCreateDefaultValues(actualArgs);
    String name = actualArgs.get(Task.TASK_NAME).toString();
    if (!GUtil.isTrue(name)) {
        throw new InvalidUserDataException("The task name must be provided.");
    }
    Class<? extends TaskInternal> type = (Class) actualArgs.get(Task.TASK_TYPE);
    TaskInternal task = create(name, type);
    Object dependsOnTasks = actualArgs.get(Task.TASK_DEPENDS_ON);
    if (dependsOnTasks != null) {
        task.dependsOn(dependsOnTasks);
    }
    Object description = actualArgs.get(Task.TASK_DESCRIPTION);
    if (description != null) {
        task.setDescription(description.toString());
    }
    Object group = actualArgs.get(Task.TASK_GROUP);
    if (group != null) {
        task.setGroup(group.toString());
    }
    Object action = actualArgs.get(Task.TASK_ACTION);
    if (action instanceof Action) {
        Action<? super Task> taskAction = (Action<? super Task>) action;
        task.doFirst(taskAction);
    } else if (action != null) {
        Closure closure = (Closure) action;
        task.doFirst(closure);
    }
    return task;
}

Example 4 with Action

use of org.gradle.api.Action in project gradle by gradle.

the class DependencyGraphBuilder method traverseGraph.

/**
     * Traverses the dependency graph, resolving conflicts and building the paths from the root configuration.
     */
private void traverseGraph(final ResolveState resolveState, final ConflictHandler conflictHandler) {
    resolveState.onMoreSelected(resolveState.root);
    List<DependencyEdge> dependencies = new ArrayList<DependencyEdge>();
    while (resolveState.peek() != null || conflictHandler.hasConflicts()) {
        if (resolveState.peek() != null) {
            ConfigurationNode node = resolveState.pop();
            LOGGER.debug("Visiting configuration {}.", node);
            // Calculate the outgoing edges of this configuration
            dependencies.clear();
            node.visitOutgoingDependencies(dependencies);
            for (DependencyEdge dependency : dependencies) {
                LOGGER.debug("Visiting dependency {}", dependency);
                // Resolve dependency to a particular revision
                ModuleVersionResolveState moduleRevision = dependency.resolveModuleRevisionId();
                if (moduleRevision == null) {
                    // Failed to resolve.
                    continue;
                }
                ModuleIdentifier moduleId = moduleRevision.id.getModule();
                // Check for a new conflict
                if (moduleRevision.state == ModuleState.New) {
                    ModuleResolveState module = resolveState.getModule(moduleId);
                    // A new module revision. Check for conflict
                    PotentialConflict c = conflictHandler.registerModule(module);
                    if (!c.conflictExists()) {
                        // No conflict. Select it for now
                        LOGGER.debug("Selecting new module version {}", moduleRevision);
                        module.select(moduleRevision);
                    } else {
                        // We have a conflict
                        LOGGER.debug("Found new conflicting module version {}", moduleRevision);
                        // Deselect the currently selected version, and remove all outgoing edges from the version
                        // This will propagate through the graph and prune configurations that are no longer required
                        // For each module participating in the conflict (many times there is only one participating module that has multiple versions)
                        c.withParticipatingModules(new Action<ModuleIdentifier>() {

                            public void execute(ModuleIdentifier module) {
                                ModuleVersionResolveState previouslySelected = resolveState.getModule(module).clearSelection();
                                if (previouslySelected != null) {
                                    for (ConfigurationNode configuration : previouslySelected.configurations) {
                                        configuration.deselect();
                                    }
                                }
                            }
                        });
                    }
                }
                dependency.attachToTargetConfigurations();
            }
        } else {
            // We have some batched up conflicts. Resolve the first, and continue traversing the graph
            conflictHandler.resolveNextConflict(new Action<ConflictResolutionResult>() {

                public void execute(final ConflictResolutionResult result) {
                    result.getConflict().withParticipatingModules(new Action<ModuleIdentifier>() {

                        public void execute(ModuleIdentifier moduleIdentifier) {
                            ModuleVersionResolveState selected = result.getSelected();
                            // Restart each configuration. For the evicted configuration, this means moving incoming dependencies across to the
                            // matching selected configuration. For the select configuration, this mean traversing its dependencies.
                            resolveState.getModule(moduleIdentifier).restart(selected);
                        }
                    });
                }
            });
        }
    }
}

Example 5 with Action

use of org.gradle.api.Action in project gradle by gradle.

the class DefaultTestReport method generateFiles.

private void generateFiles(AllTestResults model, final TestResultsProvider resultsProvider, File reportDir) {
    try {
        HtmlReportRenderer htmlRenderer = new HtmlReportRenderer();
        htmlRenderer.render(model, new ReportRenderer<AllTestResults, HtmlReportBuilder>() {

            @Override
            public void render(final AllTestResults model, final HtmlReportBuilder output) throws IOException {
                buildOperationProcessor.run(new Action<BuildOperationQueue<HtmlReportFileGenerator<? extends CompositeTestResults>>>() {

                    @Override
                    public void execute(BuildOperationQueue<HtmlReportFileGenerator<? extends CompositeTestResults>> queue) {
                        queue.add(generator("index.html", model, new OverviewPageRenderer(), output));
                        for (PackageTestResults packageResults : model.getPackages()) {
                            queue.add(generator(packageResults.getBaseUrl(), packageResults, new PackagePageRenderer(), output));
                            for (ClassTestResults classResults : packageResults.getClasses()) {
                                queue.add(generator(classResults.getBaseUrl(), classResults, new ClassPageRenderer(resultsProvider), output));
                            }
                        }
                    }
                });
            }
        }, reportDir);
    } catch (Exception e) {
        throw new GradleException(String.format("Could not generate test report to '%s'.", reportDir), e);
    }
}