Build with Buck
Implement a new build system using Buck[1], Facebook's
open source clone of Google's internal build system.
Pros:
- Concise build language
- Test and build output is concise
- Test failures and stack traces show on terminal
- Reliable incrementals; clean is unnecessary
- Extensible with simple blocks of Python
- Fast
buck: clean: 0.452s, full 1m21.083s [*], no-op: 7.145s,
mvn: clean: 4.596s, full 2m53.776s, no-op: 59.108s,
[*] full build includes downloading all dependencies,
time can vary due to remote server performance.
Cons:
- No Windows support
- No native Maven Central support (added by macros)
- No native GWT, Prolog, or WAR support (added by macros)
- Bootstrap of buck requires Ant
Getting started:
git clone https://gerrit.googlesource.com/buck
cd buck
ant
Mac OS X:
PATH="`pwd`/bin:/System/Library/Frameworks/JavaVM.framework/Versions/Current/Commands:$PATH"
Linux:
PATH="`pwd`/bin:$PATH"
Importing into Eclipse:
$ time buck build :eclipse
0m48.949s
Import existing project from `pwd`
Import 'gerrit' (do not import other Maven based projects)
Expand 'gerrit'
Right click 'buck-out' > Properties
Under Attributes check 'Derived'
If the code doesn't currently compile but an updated classpath
is needed, refresh the configs and obtain missing JARs:
$ buck build :eclipse_project :download
Running JUnit tests:
$ time buck test --all -e slow # skip slow tests
0m19.320s
$ time buck test --all # includes acceptance tests
5m17.517s
Building WAR:
$ buck build :gerrit
$ java -jar buck-out/gen/gerrit.war
Building release:
$ buck test --all && buck build :api :release
$ java -jar buck-out/gen/release.war
$ ls -lh buck-out/gen/{extension,plugin}-api.jar
Downloading dependencies:
Dependencies are normally downloaded automatically, but Buck can
inspect its graph and download missing dependencies so future
compiles can run without the network:
$ buck build :download
[1] http://facebook.github.io/buck/
Change-Id: I40853b108bd8e153cefa0896a5280a9a5ff81655
diff --git a/lib/prolog/java/BuckPrologCompiler.java b/lib/prolog/java/BuckPrologCompiler.java
new file mode 100644
index 0000000..d23e15d
--- /dev/null
+++ b/lib/prolog/java/BuckPrologCompiler.java
@@ -0,0 +1,166 @@
+// Copyright (C) 2013 The Android Open Source Project
+//
+// 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.
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Locale;
+import java.util.jar.JarEntry;
+import java.util.jar.JarOutputStream;
+
+import javax.tools.Diagnostic;
+import javax.tools.DiagnosticCollector;
+import javax.tools.JavaCompiler;
+import javax.tools.JavaFileObject;
+import javax.tools.StandardJavaFileManager;
+import javax.tools.ToolProvider;
+
+import com.googlecode.prolog_cafe.compiler.CompileException;
+import com.googlecode.prolog_cafe.compiler.Compiler;
+
+public class BuckPrologCompiler {
+ public static void main(String[] argv) throws IOException, CompileException {
+ List<File> srcs = new ArrayList<File>();
+ List<File> jars = new ArrayList<File>();
+ for (int i = 0; i < argv.length - 1; i++) {
+ String s = argv[i];
+ if (s.endsWith(".pl")) {
+ srcs.add(new File(s));
+ } else if (s.endsWith(".jar")) {
+ jars.add(new File(s));
+ }
+ }
+
+ File out = new File(argv[argv.length - 1]);
+ File java = tmpdir("java");
+ File classes = tmpdir("classes");
+ for (File src : srcs) {
+ new Compiler().prologToJavaSource(src.getPath(), java.getPath());
+ }
+ javac(jars, java, classes);
+ jar(out, classes);
+ }
+
+ private static File tmpdir(String name) throws IOException {
+ File d = File.createTempFile(name + "_", "");
+ if (!d.delete() || !d.mkdir()) {
+ throw new IOException("Cannot mkdir " + d);
+ }
+ return d;
+ }
+
+ private static void javac(List<File> cp, File java, File classes)
+ throws IOException, CompileException {
+ JavaCompiler javac = ToolProvider.getSystemJavaCompiler();
+ if (javac == null) {
+ throw new CompileException("JDK required (running inside of JRE)");
+ }
+
+ DiagnosticCollector<JavaFileObject> d =
+ new DiagnosticCollector<JavaFileObject>();
+ StandardJavaFileManager fm = javac.getStandardFileManager(d, null, null);
+ try {
+ StringBuilder classpath = new StringBuilder();
+ for (File jar : cp) {
+ if (classpath.length() > 0) {
+ classpath.append(File.pathSeparatorChar);
+ }
+ classpath.append(jar.getPath());
+ }
+ ArrayList<String> args = new ArrayList<String>();
+ args.add("-g:none");
+ args.add("-nowarn");
+ if (classpath.length() > 0) {
+ args.add("-classpath");
+ args.add(classpath.toString());
+ }
+ args.add("-d");
+ args.add(classes.getPath());
+ if (!javac.getTask(null, fm, d, args, null,
+ fm.getJavaFileObjectsFromFiles(find(java, ".java"))).call()) {
+ StringBuilder msg = new StringBuilder();
+ for (Diagnostic<? extends JavaFileObject> err : d.getDiagnostics()) {
+ msg.append('\n').append(err.getKind()).append(": ");
+ if (err.getSource() != null) {
+ msg.append(err.getSource().getName());
+ }
+ msg.append(':').append(err.getLineNumber()).append(": ");
+ msg.append(err.getMessage(Locale.getDefault()));
+ }
+ throw new CompileException(msg.toString());
+ }
+ } finally {
+ fm.close();
+ }
+ }
+
+ private static void jar(File jar, File classes) throws IOException {
+ File tmp = File.createTempFile("prolog", ".jar", jar.getParentFile());
+ try {
+ JarOutputStream out = new JarOutputStream(new FileOutputStream(tmp));
+ try {
+ out.setLevel(9);
+ add(out, classes, "");
+ } finally {
+ out.close();
+ }
+ if (!tmp.renameTo(jar)) {
+ throw new IOException("Cannot create " + jar);
+ }
+ } finally {
+ tmp.delete();
+ }
+ }
+
+ private static void add(JarOutputStream out, File classes, String prefix)
+ throws IOException {
+ for (String name : classes.list()) {
+ File f = new File(classes, name);
+ if (f.isDirectory()) {
+ add(out, f, prefix + name + "/");
+ continue;
+ }
+
+ JarEntry e = new JarEntry(prefix + name);
+ FileInputStream in = new FileInputStream(f);
+ try {
+ e.setTime(f.lastModified());
+ out.putNextEntry(e);
+ byte[] buf = new byte[16 << 10];
+ int n;
+ while (0 < (n = in.read(buf))) {
+ out.write(buf, 0, n);
+ }
+ } finally {
+ in.close();
+ out.closeEntry();
+ }
+ }
+ }
+
+ private static List<File> find(File dir, String extension) {
+ ArrayList<File> list = new ArrayList<File>();
+ for (File f : dir.listFiles()) {
+ if (f.getName().endsWith(extension)) {
+ list.add(f);
+ } else if (f.isDirectory()) {
+ list.addAll(find(f, extension));
+ }
+ }
+ return list;
+ }
+}
