All Downloads are FREE. Search and download functionalities are using the official Maven repository.

org.xtext.gradle.idea.tasks.DownloadPlugins Maven / Gradle / Ivy

Go to download

A plugin for for building IntelliJ IDEA Xtext plugins

There is a newer version: 2.0.9-alpha.3
Show newest version
package org.xtext.gradle.idea.tasks;

import com.google.common.collect.Iterables;
import groovy.util.XmlSlurper;
import groovy.util.slurpersupport.GPathResult;
import groovy.util.slurpersupport.Node;
import java.io.File;
import java.io.InputStream;
import java.net.URL;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardCopyOption;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.TreeSet;
import org.eclipse.xtend.lib.annotations.Accessors;
import org.eclipse.xtend2.lib.StringConcatenation;
import org.eclipse.xtext.xbase.lib.CollectionLiterals;
import org.eclipse.xtext.xbase.lib.Conversions;
import org.eclipse.xtext.xbase.lib.Exceptions;
import org.eclipse.xtext.xbase.lib.Functions.Function1;
import org.eclipse.xtext.xbase.lib.IterableExtensions;
import org.eclipse.xtext.xbase.lib.IteratorExtensions;
import org.eclipse.xtext.xbase.lib.Pair;
import org.eclipse.xtext.xbase.lib.Procedures.Procedure1;
import org.eclipse.xtext.xbase.lib.Pure;
import org.gradle.StartParameter;
import org.gradle.api.DefaultTask;
import org.gradle.api.Project;
import org.gradle.api.Task;
import org.gradle.api.file.CopySpec;
import org.gradle.api.file.FileTree;
import org.gradle.api.internal.TaskOutputsInternal;
import org.gradle.api.invocation.Gradle;
import org.gradle.api.specs.Spec;
import org.gradle.api.tasks.OutputDirectory;
import org.gradle.api.tasks.TaskAction;
import org.gradle.api.tasks.WorkResult;
import org.xtext.gradle.idea.tasks.ExternalIdeaPluginDependency;
import org.xtext.gradle.idea.tasks.GradleExtensions;
import org.xtext.gradle.idea.tasks.IdeaPluginDependencies;
import org.xtext.gradle.idea.tasks.IdeaPluginRepositories;
import org.xtext.gradle.idea.tasks.IdeaPluginRepository;

@Accessors
@SuppressWarnings("all")
public class DownloadPlugins extends DefaultTask {
  @OutputDirectory
  private File destinationDir;
  
  private IdeaPluginRepositories pluginRepositories;
  
  private IdeaPluginDependencies pluginDependencies;
  
  public DownloadPlugins() {
    TaskOutputsInternal _outputs = this.getOutputs();
    final Spec _function = new Spec() {
      @Override
      public boolean isSatisfiedBy(final Task it) {
        boolean _xblockexpression = false;
        {
          List _elvis = null;
          String[] _list = DownloadPlugins.this.destinationDir.list();
          List _list_1 = null;
          if (((Iterable)Conversions.doWrapArray(_list))!=null) {
            _list_1=IterableExtensions.toList(((Iterable)Conversions.doWrapArray(_list)));
          }
          if (_list_1 != null) {
            _elvis = _list_1;
          } else {
            _elvis = Collections.unmodifiableList(CollectionLiterals.newArrayList());
          }
          final List existingDirs = _elvis;
          boolean _and = false;
          Project _project = it.getProject();
          Gradle _gradle = _project.getGradle();
          StartParameter _startParameter = _gradle.getStartParameter();
          boolean _isRefreshDependencies = _startParameter.isRefreshDependencies();
          boolean _not = (!_isRefreshDependencies);
          if (!_not) {
            _and = false;
          } else {
            TreeSet _externalPluginDependencies = DownloadPlugins.this.externalPluginDependencies();
            final Function1 _function = new Function1() {
              @Override
              public Boolean apply(final ExternalIdeaPluginDependency it) {
                String _id = it.getId();
                return Boolean.valueOf(existingDirs.contains(_id));
              }
            };
            boolean _forall = IterableExtensions.forall(_externalPluginDependencies, _function);
            _and = _forall;
          }
          _xblockexpression = _and;
        }
        return _xblockexpression;
      }
    };
    _outputs.upToDateWhen(_function);
  }
  
  @TaskAction
  public void download() {
    final HashMap urlsByPluginId = this.collectUrlsByPluginId();
    TreeSet _externalPluginDependencies = this.externalPluginDependencies();
    final Procedure1 _function = new Procedure1() {
      @Override
      public void apply(final ExternalIdeaPluginDependency it) {
        String _id = it.getId();
        String _id_1 = it.getId();
        String _get = urlsByPluginId.get(_id_1);
        DownloadPlugins.this.download(_id, _get);
      }
    };
    IterableExtensions.forEach(_externalPluginDependencies, _function);
  }
  
  public TreeSet externalPluginDependencies() {
    return this.pluginDependencies.getExternalDependencies();
  }
  
  public WorkResult download(final String pluginId, final String downloadUrl) {
    try {
      WorkResult _xblockexpression = null;
      {
        StringConcatenation _builder = new StringConcatenation();
        _builder.append(pluginId, "");
        _builder.append(".zip");
        final File targetFile = GradleExtensions.operator_divide(this.destinationDir, _builder.toString());
        URL _uRL = new URL(downloadUrl);
        InputStream _openStream = _uRL.openStream();
        Path _path = targetFile.toPath();
        Files.copy(_openStream, _path, StandardCopyOption.REPLACE_EXISTING);
        Project _project = this.getProject();
        final Procedure1 _function = new Procedure1() {
          @Override
          public void apply(final CopySpec it) {
            Project _project = DownloadPlugins.this.getProject();
            FileTree _zipTree = _project.zipTree(targetFile);
            it.from(_zipTree);
            it.into(DownloadPlugins.this.destinationDir);
          }
        };
        _xblockexpression = GradleExtensions.copy(_project, _function);
      }
      return _xblockexpression;
    } catch (Throwable _e) {
      throw Exceptions.sneakyThrow(_e);
    }
  }
  
  public HashMap collectUrlsByPluginId() {
    final Function1>> _function = new Function1>>() {
      @Override
      public Iterable> apply(final IdeaPluginRepository it) {
        try {
          Iterable> _xblockexpression = null;
          {
            XmlSlurper _xmlSlurper = new XmlSlurper();
            String _url = it.getUrl();
            final GPathResult result = _xmlSlurper.parse(_url);
            Iterator _childNodes = result.childNodes();
            Iterable _iterable = IteratorExtensions.toIterable(_childNodes);
            Iterable _filter = Iterables.filter(_iterable, Node.class);
            final Function1> _function = new Function1>() {
              @Override
              public Pair apply(final Node it) {
                Map _attributes = it.attributes();
                Object _get = _attributes.get("id");
                Map _attributes_1 = it.attributes();
                Object _get_1 = _attributes_1.get("url");
                return Pair.of(((String) _get), ((String) _get_1));
              }
            };
            _xblockexpression = IterableExtensions.>map(_filter, _function);
          }
          return _xblockexpression;
        } catch (Throwable _e) {
          throw Exceptions.sneakyThrow(_e);
        }
      }
    };
    Iterable>> _map = IterableExtensions.>>map(this.pluginRepositories, _function);
    Iterable> _flatten = Iterables.>concat(_map);
    return CollectionLiterals.newHashMap(((Pair[])Conversions.unwrapArray(_flatten, Pair.class)));
  }
  
  @Pure
  public File getDestinationDir() {
    return this.destinationDir;
  }
  
  public void setDestinationDir(final File destinationDir) {
    this.destinationDir = destinationDir;
  }
  
  @Pure
  public IdeaPluginRepositories getPluginRepositories() {
    return this.pluginRepositories;
  }
  
  public void setPluginRepositories(final IdeaPluginRepositories pluginRepositories) {
    this.pluginRepositories = pluginRepositories;
  }
  
  @Pure
  public IdeaPluginDependencies getPluginDependencies() {
    return this.pluginDependencies;
  }
  
  public void setPluginDependencies(final IdeaPluginDependencies pluginDependencies) {
    this.pluginDependencies = pluginDependencies;
  }
}
 















© 2015 - 2024 Weber Informatics LLC | Privacy Policy