azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial implementation of maven plugin

Browse Source
This commit is contained in:
Leonid Shalupov
2012-04-03 16:49:53 +04:00
parent e9788c12d9
commit 013ebf46db
7 changed files with 314 additions and 89 deletions
Download Patch File Download Diff File Expand all files Collapse all files
libraries/kotlin-maven-plugin/src/main/java/org/jetbrains/kotlin/maven/K2JSCompilerMojo.java
+21 -10
View File
@@ -1,5 +1,22 @@
/*
* Copyright 2010-2012 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jetbrains.kotlin.maven;
import org.apache.maven.plugin.MojoExecutionException;
import org.jetbrains.jet.cli.CompilerArguments;
/**
@@ -8,8 +25,7 @@ import org.jetbrains.jet.cli.CompilerArguments;
* @goal js
* @phase compile
*/
public class K2JSCompilerMojo extends KotlinBaseMojo {
public class K2JSCompilerMojo extends KotlinCompileMojo {
/**
* The output JS file name
*
@@ -19,18 +35,13 @@ public class K2JSCompilerMojo extends KotlinBaseMojo {
private String outFile;
@Override
protected void configureCompilerArguments(CompilerArguments arguments) {
protected void configureCompilerArguments(CompilerArguments arguments) throws MojoExecutionException {
super.configureCompilerArguments(arguments);
K2JSCompilerPlugin plugin = new K2JSCompilerPlugin();
plugin.setOutFile(outFile);
arguments.getCompilerPlugins().add(plugin);
getLog().info("Compiling Kotlin src from " + arguments.getSrc() + " to JavaScript at: " + outFile);
}
@Override
protected CompilerArguments createCompilerArguments() {
CompilerArguments answer = new CompilerArguments();
return answer;
}
}
libraries/kotlin-maven-plugin/src/main/java/org/jetbrains/kotlin/maven/K2JSCompilerPlugin.java
+22 -17
View File
@@ -1,7 +1,23 @@
/*
* Copyright 2010-2012 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jetbrains.kotlin.maven;
import com.google.common.io.Files;
import com.intellij.openapi.project.Project;
import jet.Function1;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.compiler.CompilerPlugin;
import org.jetbrains.jet.compiler.CompilerPluginContext;
@@ -11,13 +27,11 @@ import org.jetbrains.k2js.config.Config;
import org.jetbrains.k2js.facade.K2JSTranslator;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.List;
import static kotlin.io.namespace.use;
/**
* Compiles Kotlin code to JavaScript
*/
@@ -30,6 +44,7 @@ public class K2JSCompilerPlugin implements CompilerPlugin {
Project project = context.getProject();
BindingContext bindingContext = context.getContext();
List<JetFile> sources = context.getFiles();
if (bindingContext != null && sources != null && project != null) {
Config config = new Config(project) {
@NotNull
@@ -38,6 +53,7 @@ public class K2JSCompilerPlugin implements CompilerPlugin {
return new ArrayList<JetFile>();
}
};
K2JSTranslator translator = new K2JSTranslator(config);
final String code = translator.generateProgramCode(sources);
File file = new File(outFile);
@@ -46,20 +62,9 @@ public class K2JSCompilerPlugin implements CompilerPlugin {
outDir.mkdirs();
}
try {
use(new FileWriter(file), new Function1<FileWriter, Object>() {
@Override
public Object invoke(FileWriter writer) {
try {
writer.write(code);
} catch (IOException e) {
throw new RuntimeException(e);
}
return null;
}
});
Files.write(code, file, Charset.forName("UTF-8"));
} catch (IOException e) {
System.out.println("Error: " + e);
e.printStackTrace();
throw new RuntimeException(e);
}
}
}
libraries/kotlin-maven-plugin/src/main/java/org/jetbrains/kotlin/maven/KotlinBaseMojo.java
-62
View File
@@ -1,62 +0,0 @@
package org.jetbrains.kotlin.maven;
import org.apache.maven.plugin.AbstractMojo;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugin.MojoFailureException;
import org.jetbrains.jet.cli.CompilerArguments;
import org.jetbrains.jet.cli.KotlinCompiler;
/**
* Abstract base class for Kotlin maven plugins
*/
public abstract class KotlinBaseMojo extends AbstractMojo {
private KotlinCompiler compiler = new KotlinCompiler();
private CompilerArguments arguments;
/**
* The source directory to compile
*
* @required
* @parameter default-value="${basedir}/src/main/kotlin"
*/
private String src;
/**
* The output directory for bytecode classes
*
* @required
* @parameter default-value="${project.build.directory}/classes"
*/
private String outputDir;
@Override
public void execute() throws MojoExecutionException, MojoFailureException {
arguments = createCompilerArguments();
if (src != null) {
arguments.setSrc(src);
}
if (outputDir != null) {
arguments.setOutputDir(outputDir);
}
configureCompilerArguments(arguments);
compiler.exec(System.err, arguments);
}
/**
* Derived classes can create custom compiler argument implementations
* such as for KDoc
*/
protected CompilerArguments createCompilerArguments() {
return new CompilerArguments();
}
/**
* Derived classes can register custom plugins or configurations
*/
protected void configureCompilerArguments(CompilerArguments arguments) {
}
}
libraries/kotlin-maven-plugin/src/main/java/org/jetbrains/kotlin/maven/KotlinCompileMojo.java
+35
View File
@@ -0,0 +1,35 @@
/*
* Copyright 2010-2012 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jetbrains.kotlin.maven;
import org.apache.maven.plugin.MojoExecutionException;
import org.jetbrains.jet.cli.CompilerArguments;
/**
* Compiles kotlin sources
*
* @goal compile
* @phase compile
* @requiresDependencyResolution compile
*/
public class KotlinCompileMojo extends KotlinCompileMojoBase {
@Override
protected void configureCompilerArguments(CompilerArguments arguments) throws MojoExecutionException {
configureBaseCompilerArguments(getLog(), arguments, module, sources, classpath, output);
}
}
libraries/kotlin-maven-plugin/src/main/java/org/jetbrains/kotlin/maven/KotlinCompileMojoBase.java
+167
View File
@@ -0,0 +1,167 @@
/*
* Copyright 2010-2012 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jetbrains.kotlin.maven;
import com.google.common.base.Joiner;
import org.apache.maven.plugin.AbstractMojo;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugin.MojoFailureException;
import org.apache.maven.plugin.logging.Log;
import org.jetbrains.jet.cli.CompilerArguments;
import org.jetbrains.jet.cli.KotlinCompiler;
import java.io.File;
import java.util.ArrayList;
import java.util.List;
public abstract class KotlinCompileMojoBase extends AbstractMojo {
/**
* The source directories containing the sources to be compiled.
*
* @parameter default-value="${project.compileSourceRoots}"
* @required
* @readonly
*/
public List<String> sources;
/**
* The source directories containing the sources to be compiled for tests.
*
* @parameter default-value="${project.testCompileSourceRoots}"
* @required
* @readonly
*/
protected List<String> testSources;
/**
* Project classpath.
*
* @parameter default-value="${project.compileClasspathElements}"
* @required
* @readonly
*/
public List<String> classpath;
/**
* Project test classpath.
*
* @parameter default-value="${project.testClasspathElements}"
* @required
* @readonly
*/
protected List<String> testClasspath;
/**
* The directory for compiled classes.
*
* @parameter default-value="${project.build.outputDirectory}"
* @required
* @readonly
*/
public String output;
/**
* The directory for compiled tests classes.
*
* @parameter default-value="${project.build.testOutputDirectory}"
* @required
* @readonly
*/
public String testOutput;
/**
* Kotlin compilation module, as alternative to source files or folders.
*
* @parameter
*/
public String module;
/**
* Kotlin compilation module, as alternative to source files or folders (for tests).
*
* @parameter
*/
public String testModule;
@Override
public void execute() throws MojoExecutionException, MojoFailureException {
final CompilerArguments arguments = createCompilerArguments();
configureCompilerArguments(arguments);
final KotlinCompiler compiler = createCompiler();
final KotlinCompiler.ExitCode exitCode = compiler.exec(System.err, arguments);
switch (exitCode) {
case COMPILATION_ERROR:
throw new MojoExecutionException("Compilation error. See log for more details");
case INTERNAL_ERROR:
throw new MojoExecutionException("Internal compiler error. See log for more details");
}
}
protected KotlinCompiler createCompiler() {
return new KotlinCompiler();
}
/**
* Derived classes can create custom compiler argument implementations
* such as for KDoc
*/
protected CompilerArguments createCompilerArguments() {
return new CompilerArguments();
}
/**
* Derived classes can register custom plugins or configurations
*/
protected abstract void configureCompilerArguments(CompilerArguments arguments) throws MojoExecutionException;
protected static void configureBaseCompilerArguments(Log log, CompilerArguments arguments, String module,
List<String> sources, List<String> classpath, String output) throws MojoExecutionException {
if (module != null) {
log.info("Compiling Kotlin module " + module);
arguments.setModule(module);
} else {
if (sources.size() <= 0)
throw new MojoExecutionException("No source roots to compile");
if (sources.size() > 1)
throw new MojoExecutionException("Multiple source roots are not supported yet");
final String src = sources.get(0);
log.info("Compiling Kotlin sources from " + src);
arguments.setSrc(src);
}
final ArrayList<String> classpathList = new ArrayList<String>(classpath);
if (classpathList.remove(output)) {
log.debug("Removed target directory from classpath (" + output + ")");
}
final String classPathString = Joiner.on(File.pathSeparator).join(classpathList);
log.info("Classpath: " + classPathString);
arguments.setClasspath(classPathString);
log.info("Classes directory is " + output);
arguments.setOutputDir(output);
}
}
libraries/kotlin-maven-plugin/src/main/java/org/jetbrains/kotlin/maven/KotlinTestCompileMojo.java
+53
View File
@@ -0,0 +1,53 @@
/*
* Copyright 2010-2012 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jetbrains.kotlin.maven;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugin.MojoFailureException;
import org.jetbrains.jet.cli.CompilerArguments;
/**
* Compiles Kotlin test sources
*
* @goal test-compile
* @phase test-compile
* @requiresDependencyResolution test
*/
public class KotlinTestCompileMojo extends KotlinCompileMojoBase {
/**
* Flag to allow test compilation to be skipped.
*
* @parameter expression="${maven.test.skip}" default-value="false"
* @noinspection UnusedDeclaration
*/
private boolean skip;
public void execute() throws MojoExecutionException, MojoFailureException {
if (skip) {
getLog().info("Test compilation is skipped");
} else {
super.execute();
}
}
@Override
protected void configureCompilerArguments(CompilerArguments arguments) throws MojoExecutionException {
configureBaseCompilerArguments(
getLog(), arguments,
testModule, testSources, testClasspath, testOutput);
}
}
libraries/kotlin-maven-plugin/src/test/java/org/jetbrains/kotlin/maven/MojoTest.java
+16
View File
@@ -1,3 +1,19 @@
/*
* Copyright 2010-2012 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jetbrains.kotlin.maven;
import org.junit.Test;