Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.xtext.gradle.tasks;
  
  import java.io.File;
  import java.net.URI;
  import java.net.URL;
 import java.util.List;
 import java.util.Set;
 import  org.gradle.api.DefaultTask;
 import  org.gradle.api.GradleException;
 import  org.gradle.api.NamedDomainObjectContainer;
 import  org.gradle.api.Project;
 import  org.gradle.api.file.FileCollection;
 import  org.gradle.api.file.SourceDirectorySet;
 import  org.gradle.api.internal.TaskOutputsInternal;
 import  org.gradle.api.specs.Spec;
 import  org.gradle.api.tasks.InputFiles;
 import  org.gradle.api.tasks.TaskAction;
 import  org.gradle.api.tasks.TaskInputs;
 import  org.gradle.internal.classloader.FilteringClassLoader;
 
 public class XtextGenerate extends DefaultTask {
   private XtextExtension xtext;
   
   @InputFiles
   private FileCollection xtextClasspath;
   
   @InputFiles
   private FileCollection classpath;
   
   public TaskInputs configure(final XtextExtension xtext) {
     TaskInputs _xblockexpression = null;
     {
       this. = xtext;
       NamedDomainObjectContainer<Language_languages = xtext.getLanguages();
       final Procedure1<Language_function = new Procedure1<Language>() {
         public void apply(final Language lang) {
           NamedDomainObjectContainer<OutputConfiguration_outputs = lang.getOutputs();
           final Procedure1<OutputConfiguration_function = new Procedure1<OutputConfiguration>() {
             public void apply(final OutputConfiguration output) {
               TaskOutputsInternal _outputs = XtextGenerate.this.getOutputs();
               Object _dir = output.getDir();
               _outputs.dir(_dir);
             }
           };
           IterableExtensions.<OutputConfiguration>forEach(_outputs_function);
         }
       };
       IterableExtensions.<Language>forEach(_languages_function);
       TaskInputs _inputs = this.getInputs();
       SourceDirectorySet _sources = xtext.getSources();
       _xblockexpression = _inputs.source(_sources);
     }
     return _xblockexpression;
   }
   
   @TaskAction
   public void generate() {
     String _encoding = this..getEncoding();
     Project _project = this.getProject();
     File _projectDir = _project.getProjectDir();
     String _absolutePath = _projectDir.getAbsolutePath();
     FileCollection _classpath = this.getClasspath();
     String _asPath = _classpath.getAsPath();
     Project _project_1 = this.getProject();
     File _buildDir = _project_1.getBuildDir();
     File _file = new File(_buildDir"xtext-temp");
     String _absolutePath_1 = _file.getAbsolutePath();
     final ArrayList<Stringargs = CollectionLiterals.<String>newArrayList(
       "-encoding"_encoding
       "-cwd"_absolutePath
       "-classpath"_asPath
       "-tempdir"_absolutePath_1);
     NamedDomainObjectContainer<Language_languages = this..getLanguages();
     final Procedure1<Language_function = new Procedure1<Language>() {
       public void apply(final Language language) {
         StringConcatenation _builder = new StringConcatenation();
         _builder.append("-L");
        String _name = language.getName();
        _builder.append(_name"");
        _builder.append(".setup=");
        String _setup = language.getSetup();
        _builder.append(_setup"");
        StringConcatenation _builder_1 = new StringConcatenation();
        _builder_1.append("-L");
        String _name_1 = language.getName();
        _builder_1.append(_name_1"");
        _builder_1.append(".javaSupport=");
        boolean _isConsumesJava = language.isConsumesJava();
        _builder_1.append(_isConsumesJava"");
        Iterables.<String>addAll(args, Collections.<String>unmodifiableList(CollectionLiterals.<String>newArrayList(_builder.toString(), _builder_1.toString())));
        NamedDomainObjectContainer<OutputConfiguration_outputs = language.getOutputs();
        final Procedure1<OutputConfiguration_function = new Procedure1<OutputConfiguration>() {
          public void apply(final OutputConfiguration output) {
            StringConcatenation _builder = new StringConcatenation();
            _builder.append("-L");
            String _name = language.getName();
            _builder.append(_name"");
            _builder.append(".");
            String _name_1 = output.getName();
            _builder.append(_name_1"");
            _builder.append(".dir=");
            Object _dir = output.getDir();
            _builder.append(_dir"");
            StringConcatenation _builder_1 = new StringConcatenation();
            _builder_1.append("-L");
            String _name_2 = language.getName();
            _builder_1.append(_name_2"");
            _builder_1.append(".");
            String _name_3 = output.getName();
            _builder_1.append(_name_3"");
            _builder_1.append(".createDir=true");
            Iterables.<String>addAll(args, Collections.<String>unmodifiableList(CollectionLiterals.<String>newArrayList(_builder.toString(), _builder_1.toString())));
          }
        };
        IterableExtensions.<OutputConfiguration>forEach(_outputs_function);
      }
    };
    IterableExtensions.<Language>forEach(_languages_function);
    SourceDirectorySet _sources = this..getSources();
    Set<File_srcDirs = _sources.getSrcDirs();
    final Function1<FileString_function_1 = new Function1<FileString>() {
      public String apply(final File it) {
        return it.getAbsolutePath();
      }
    };
    Iterable<String_map = IterableExtensions.<FileString>map(_srcDirs_function_1);
    Iterables.<String>addAll(args_map);
    this.generate(args);
  }
  
  public void generate(final List<Stringarguments) {
    try {
      System.setProperty("org.eclipse.emf.common.util.ReferenceClearingQueue""false");
      Thread _currentThread = Thread.currentThread();
      final ClassLoader contextClassLoader = _currentThread.getContextClassLoader();
      FileCollection _xtextClasspath = this.getXtextClasspath();
      final URLClassLoader classLoader = this.getCompilerClassLoader(_xtextClasspath);
      try {
        Thread _currentThread_1 = Thread.currentThread();
        _currentThread_1.setContextClassLoader(classLoader);
        final Class<?> main = classLoader.loadClass("org.xtext.builder.standalone.Main");
        final Method method = main.getMethod("generate"String[].class);
        Object _invoke = method.invoke(nullnew Object[] { ((String[]) ((String[])Conversions.unwrapArray(argumentsString.class))) });
        final Boolean success = ((Boolean_invoke);
        if ((!(success).booleanValue())) {
          StringConcatenation _builder = new StringConcatenation();
          _builder.append("Xtext generation failed");
          throw new GradleException(_builder.toString());
        }
      } finally {
        Thread _currentThread_2 = Thread.currentThread();
        _currentThread_2.setContextClassLoader(contextClassLoader);
      }
    } catch (Throwable _e) {
      throw Exceptions.sneakyThrow(_e);
    }
  }
  
    protected URLClassLoader initialValue() {
      return null;
    }
  };
  
  private URLClassLoader getCompilerClassLoader(final FileCollection classpath) {
    final Spec<File_function = new Spec<File>() {
      public boolean isSatisfiedBy(final File it) {
        String _name = it.getName();
        boolean _contains = _name.contains("log4j");
        return (!_contains);
      }
    };
    final FileCollection classPathWithoutLog4j = classpath.filter(_function);
    final Function1<FileURL_function_1 = new Function1<FileURL>() {
      public URL apply(final File it) {
        try {
          File _absoluteFile = it.getAbsoluteFile();
          URI _uRI = _absoluteFile.toURI();
          return _uRI.toURL();
        } catch (Throwable _e) {
          throw Exceptions.sneakyThrow(_e);
        }
      }
    };
    Iterable<URL_map = IterableExtensions.<FileURL>map(classPathWithoutLog4j_function_1);
    final List<URLurls = IterableExtensions.<URL>toList(_map);
    final URLClassLoader currentClassLoader = ..get();
    boolean _and = false;
    boolean _tripleNotEquals = (currentClassLoader != null);
    if (!_tripleNotEquals) {
      _and = false;
    } else {
      URL[] _uRLs = currentClassLoader.getURLs();
      List<URL_list = IterableExtensions.<URL>toList(((Iterable<URL>)Conversions.doWrapArray(_uRLs)));
      boolean _equals = Objects.equal(_listurls);
      _and = _equals;
    }
    if (_and) {
      return currentClassLoader;
    } else {
      FilteringClassLoader _loggingBridgeClassLoader = this.loggingBridgeClassLoader();
      final URLClassLoader newClassLoader = new URLClassLoader(((URL[])Conversions.unwrapArray(urlsURL.class)), _loggingBridgeClassLoader);
      ..set(newClassLoader);
      return newClassLoader;
    }
  }
  
  private FilteringClassLoader loggingBridgeClassLoader() {
    ClassLoader _classLoader = XtextGenerate.class.getClassLoader();
    FilteringClassLoader _filteringClassLoader = new FilteringClassLoader(_classLoader);
    final Procedure1<FilteringClassLoader> _function = new Procedure1<FilteringClassLoader>() {
      public void apply(final FilteringClassLoader it) {
        it.allowPackage("org.slf4j");
        it.allowPackage("org.apache.log4j");
      }
    };
    return ObjectExtensions.<FilteringClassLoader>operator_doubleArrow(_filteringClassLoader_function);
  }
  
  @Pure
  public FileCollection getXtextClasspath() {
    return this.;
  }
  
  public void setXtextClasspath(final FileCollection xtextClasspath) {
    this. = xtextClasspath;
  }
  
  @Pure
  public FileCollection getClasspath() {
    return this.;
  }
  
  public void setClasspath(final FileCollection classpath) {
    this. = classpath;
  }
New to GrepCode? Check out our FAQ X