Examples with AbstractJSProject net.vtst.ow.closure.compiler.deps.AbstractJSProject used on opensource projects

Example 1 with AbstractJSProject

use of net.vtst.ow.closure.compiler.deps.AbstractJSProject in project ow by vtst.

the class ClosureCompilerLaunchConfigurationDelegate method launch.

@Override
public void launch(ILaunchConfiguration config, String mode, ILaunch launch, IProgressMonitor monitor) throws CoreException {
    monitor.beginTask(config.getName(), 1);
    monitor.subTask(messages.getString("ClosureCompilerLaunchConfigurationDelegate_prepareCompiler"));
    IReadOnlyStore store = new LaunchConfigurationReadOnlyStore(config);
    List<IResource> resources = record.inputResources.get(store);
    if (resources.isEmpty())
        return;
    // Getting the stores for project configurations
    IProject project = null;
    if (record.useProjectPropertiesForChecks.get(store) || record.useProjectPropertiesForIncludes.get(store)) {
        project = ClosureCompiler.getCommonProject(resources);
        if (project == null)
            throw new CoreException(new Status(Status.ERROR, OwJsClosurePlugin.PLUGIN_ID, messages.getString("ClosureCompilerLaunchConfigurationDelegate_differentProjects")));
    }
    IReadOnlyStore storeForChecks = record.useProjectPropertiesForChecks.get(store) ? new ResourcePropertyStore(project, OwJsClosurePlugin.PLUGIN_ID) : store;
    IReadOnlyStore storeForIncludes = record.useProjectPropertiesForIncludes.get(store) ? new ResourcePropertyStore(project, OwJsClosurePlugin.PLUGIN_ID) : store;
    // Get the output file
    IFile outputFile = getOutputFile(store, resources);
    // Create and configure the compiler
    ClosureCompilerProcess process = new ClosureCompilerProcess(launch);
    Compiler compiler = CompilerUtils.makeCompiler(process.getErrorManager());
    CompilerOptions options = ClosureCompilerOptions.makeForLaunch(storeForChecks, store);
    compiler.initOptions(options);
    // Get the files to compile
    Set<IFile> allFiles, rootFiles;
    List<AbstractJSProject> libraries;
    if (record.manageClosureDependencies.get(store)) {
        // If dependencies are managed, we take all projects containing selected resources,
        // then all their referenced projects.
        // TODO: It should not be allowed to customize the includes in this case, we should always
        // use the project ones.
        Collection<IProject> projects = getProjects(resources);
        Comparator<IProject> comparator = OwJsClosurePlugin.getDefault().getProjectOrderManager().get().reverseOrderComparator();
        ArrayList<IProject> allProjects = ClosureCompiler.getReferencedJavaScriptProjectsRecursively(projects, comparator);
        monitor.subTask(messages.getString("ClosureCompilerLaunchConfigurationDelegate_loadLibraries"));
        libraries = includesProvider.getLibraries(compiler, monitor, allProjects);
        monitor.subTask(messages.getString("ClosureCompilerLaunchConfigurationDelegate_prepareCompiler"));
        allFiles = ClosureCompiler.getJavaScriptFilesOfProjects(allProjects);
        for (IResource resource : resources) {
            if (!(resource instanceof IProject))
                allFiles.addAll(ClosureCompiler.getJavaScriptFiles(resource));
        }
        rootFiles = Utils.getAllContainedFilesWhichAreInSet(resources, allFiles);
    } else {
        // If dependencies are not managed, we take only what has been selected.
        monitor.subTask(messages.getString("ClosureCompilerLaunchConfigurationDelegate_loadLibraries"));
        libraries = includesProvider.getLibraries(compiler, monitor, storeForIncludes);
        monitor.subTask(messages.getString("ClosureCompilerLaunchConfigurationDelegate_prepareCompiler"));
        allFiles = ClosureCompiler.getJavaScriptFiles(resources);
        rootFiles = allFiles;
    }
    // Build the project to compile
    File closureBasePath = ClosureCompiler.getPathOfClosureBase(storeForIncludes);
    Map<IFile, JSUnit> units = makeJSUnits(closureBasePath, allFiles);
    List<JSUnit> rootUnits = new ArrayList<JSUnit>(rootFiles.size());
    for (IFile selectedJsFile : rootFiles) rootUnits.add(units.get(selectedJsFile));
    try {
        JSProject jsProject = makeJSProject(compiler, Lists.newArrayList(units.values()), libraries, closureBasePath);
        List<JSUnit> rootUnitsWithTheirDependencies = jsProject.getSortedDependenciesOf(rootUnits);
        JSModule module = new JSModule("main");
        for (JSUnit unit : rootUnitsWithTheirDependencies) module.add(new CompilerInput(unit.getAst(false)));
        monitor.subTask(messages.getString("ClosureCompilerLaunchConfigurationDelegate_runCompiler"));
        compiler.compileModules(getExterns(compiler, monitor, storeForIncludes), Collections.singletonList(module), options);
        if (outputFile.exists()) {
            outputFile.setContents(new ByteArrayInputStream(compiler.toSource().getBytes("UTF-8")), false, false, monitor);
        } else {
            outputFile.create(new ByteArrayInputStream(compiler.toSource().getBytes("UTF-8")), false, monitor);
        }
        outputFile.setCharset("UTF-8", monitor);
        ClosureFilePropertyRecord.getInstance().generatedByCompiler.set(new ResourcePropertyStore(outputFile, OwJsClosurePlugin.PLUGIN_ID), true);
        process.setTerminated();
        monitor.done();
    } catch (CircularDependencyException e) {
        throw new CoreException(new Status(Status.ERROR, OwJsClosurePlugin.PLUGIN_ID, e.getLocalizedMessage(), e));
    } catch (IOException e) {
        throw new CoreException(new Status(Status.ERROR, OwJsClosurePlugin.PLUGIN_ID, e.getLocalizedMessage(), e));
    }
}

Example 2 with AbstractJSProject

use of net.vtst.ow.closure.compiler.deps.AbstractJSProject in project ow by vtst.

the class ClosureCompilerLaunchConfigurationDelegate method makeJSProject.

private JSProject makeJSProject(AbstractCompiler compiler, List<JSUnit> units, List<AbstractJSProject> libraries, File closureBasePath) throws CircularDependencyException {
    JSProject jsProject = new JSProject();
    jsProject.setUnits(compiler, units);
    jsProject.setReferencedProjects(libraries);
    return jsProject;
}

Example 3 with AbstractJSProject

use of net.vtst.ow.closure.compiler.deps.AbstractJSProject in project ow by vtst.

the class ClosureBuilder method updateJSProjectIfNeeded.

// **************************************************************************
// Referenced projects
/**
   * @param monitor  Progress monitor checked for cancellation.
   * @param compiler  Compiler used to parse libraries.
   * @param project  Project for which references shall be updated.
   * @param jsProject  Project for which references shall be updated.
   * @return true iif the project has been updated
   * @throws CoreException
   */
private boolean updateJSProjectIfNeeded(IProgressMonitor monitor, Compiler compiler, IProject project, JSProject jsProject) throws CoreException {
    // Get the referenced projects and libraries
    ProjectOrderManager.State projectOrderState = projectOrderManager.get();
    if (projectOrderState.getModificationStamp() <= jsProject.getReferencedProjectsModificationStamp())
        return false;
    OwJsDev.log("Updating referenced projects of: %s", project.getName());
    ArrayList<IProject> projects = ClosureCompiler.getReferencedJavaScriptProjectsRecursively(Collections.singleton(project), projectOrderState.reverseOrderComparator());
    Collection<AbstractJSProject> libraries = jsLibraryProvider.getLibraries(compiler, monitor, projects);
    // Build the list of referenced projects and libraries
    ArrayList<AbstractJSProject> referencedProjectsAndLibraries = new ArrayList<AbstractJSProject>(projects.size() + libraries.size());
    for (IProject referencedProject : projects) referencedProjectsAndLibraries.add(ResourceProperties.getOrCreateJSProject(referencedProject));
    referencedProjectsAndLibraries.addAll(libraries);
    // Store the results in the jsProject.
    ResourceProperties.setTransitivelyReferencedProjects(project, projects.toArray(new IProject[0]));
    jsProject.setReferencedProjects(referencedProjectsAndLibraries, projectOrderState.getModificationStamp());
    jsProject.setExterns(jsLibraryProvider.getExterns(compiler, monitor, projects));
    return true;
}

Example 4 with AbstractJSProject

use of net.vtst.ow.closure.compiler.deps.AbstractJSProject in project ow by vtst.

the class AbstractJSIncludesProvider method getLibraries.

public List<AbstractJSProject> getLibraries(AbstractCompiler compiler, IProgressMonitor monitor, ArrayList<IProject> projects) throws CoreException {
    List<AbstractJSProject> result = new ArrayList<AbstractJSProject>();
    Set<JSLibraryKey> keys = new HashSet<JSLibraryKey>();
    for (int i = projects.size() - 1; i >= 0; --i) {
        addLibraries(compiler, monitor, new ResourcePropertyStore(projects.get(i), OwJsClosurePlugin.PLUGIN_ID), keys, result);
    }
    return result;
}