From 52d4c30ca52320ec92d1d1ddc8db3f07f69c4f98 Mon Sep 17 00:00:00 2001
From: The Android Open Source Project <initial-contribution@android.com>
Date: Tue, 3 Mar 2009 19:29:09 -0800
Subject: auto import from //depot/cupcake/@135843

---
 tools/idegen/src/Eclipse.java | 188 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 188 insertions(+)
 create mode 100644 tools/idegen/src/Eclipse.java

(limited to 'tools/idegen/src/Eclipse.java')

diff --git a/tools/idegen/src/Eclipse.java b/tools/idegen/src/Eclipse.java
new file mode 100644
index 000000000..403c7d803
--- /dev/null
+++ b/tools/idegen/src/Eclipse.java
@@ -0,0 +1,188 @@
+/*
+ * Copyright (C) 2008 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.IOException;
+import java.util.SortedSet;
+import java.util.TreeMap;
+import java.util.TreeSet;
+import java.util.Collection;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.regex.Pattern;
+
+/**
+ * Generates an Eclipse project.
+ */
+public class Eclipse {
+
+    /**
+     * Generates an Eclipse .classpath file from the given configuration.
+     */
+    public static void generateFrom(Configuration c) throws IOException {
+        StringBuilder classpath = new StringBuilder();
+
+        classpath.append("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
+                + "<classpath>\n");
+
+        /*
+         * If the user has a file named "path-precedence" in their project's
+         * root directory, we'll order source roots based on how they match
+         * regular expressions in that file. Source roots that match earlier
+         * patterns will come sooner in configuration file.
+         */
+        List<Pattern> patterns = new ArrayList<Pattern>();
+
+        File precedence = new File("path-precedence");
+        if (precedence.exists()) {
+            Configuration.parseFile(precedence, patterns);
+        } else {
+            // Put ./out at the bottom by default.
+            patterns.add(Pattern.compile("^(?!out/)"));
+        }
+
+        // Everything not matched by the user's precedence spec.
+        patterns.add(Pattern.compile(".*"));
+
+
+        List<Bucket> buckets = new ArrayList<Bucket>(patterns.size());
+        for (Pattern pattern : patterns) {
+            buckets.add(new Bucket(pattern));
+        }
+
+        // Put source roots in respective buckets.
+        OUTER: for (File sourceRoot : c.sourceRoots) {
+            // Trim preceding "./" from path.
+            String path = sourceRoot.getPath().substring(2);
+
+            for (Bucket bucket : buckets) {
+                if (bucket.matches(path)) {
+                    bucket.sourceRoots.add(sourceRoot);
+                    continue OUTER;
+                }
+            }
+        }
+
+        // Output source roots to configuration file.
+        for (Bucket bucket : buckets) {
+            for (File sourceRoot : bucket.sourceRoots) {
+                classpath.append("  <classpathentry kind=\"src\"");
+                CharSequence excluding = constructExcluding(sourceRoot, c);
+                if (excluding.length() > 0) {
+                    classpath.append(" excluding=\"")
+                            .append(excluding).append("\"");
+                }
+                classpath.append(" path=\"")
+                        .append(trimmed(sourceRoot)).append("\"/>\n");
+            }
+
+        }
+
+        // Output .jar entries.
+        for (File jar : c.jarFiles) {
+            classpath.append("  <classpathentry kind=\"lib\" path=\"")
+                    .append(trimmed(jar)).append("\"/>\n");
+        }
+
+        /*
+         * Output directory. Unfortunately, Eclipse forces us to put it
+         * somewhere under the project directory.
+         */
+        classpath.append("  <classpathentry kind=\"output\" path=\""
+                + "out/eclipse\"/>\n");
+
+        classpath.append("</classpath>\n");
+
+        Files.toFile(classpath.toString(), new File(".classpath"));
+    }
+
+
+    /**
+     * Constructs the "excluding" argument for a given source root.
+     */
+    private static CharSequence constructExcluding(File sourceRoot,
+            Configuration c) {
+        StringBuilder classpath = new StringBuilder();
+        String path = sourceRoot.getPath();
+
+        // Exclude nested source roots.
+        SortedSet<File> nextRoots = c.sourceRoots.tailSet(sourceRoot);
+        int count = 0;
+        for (File nextRoot : nextRoots) {
+            // The first root is this root.
+            if (count == 0) {
+                count++;
+                continue;
+            }
+
+            String nextPath = nextRoot.getPath();
+            if (!nextPath.startsWith(path)) {
+                break;
+            }
+
+            if (count > 1) {
+                classpath.append('|');
+            }
+            classpath.append(nextPath.substring(path.length() + 1))
+                    .append('/');
+
+            count++;
+        }
+
+        // Exclude excluded directories under this source root.
+        SortedSet<File> excludedDirs = c.excludedDirs.tailSet(sourceRoot);
+        for (File excludedDir : excludedDirs) {
+            String excludedPath = excludedDir.getPath();
+            if (!excludedPath.startsWith(path)) {
+                break;
+            }
+
+            if (count > 1) {
+                classpath.append('|');
+            }
+            classpath.append(excludedPath.substring(path.length() + 1))
+                    .append('/');
+
+            count++;
+        }
+
+        return classpath;
+    }
+
+    /**
+     * Returns the trimmed path.
+     */
+    private static String trimmed(File file) {
+        return file.getPath().substring(2);
+    }
+
+    /**
+     * A precedence bucket for source roots.
+     */
+    private static class Bucket {
+
+        private final Pattern pattern;
+        private final List<File> sourceRoots = new ArrayList<File>();
+
+        private Bucket(Pattern pattern) {
+            this.pattern = pattern;
+        }
+
+        private boolean matches(String path) {
+            return pattern.matcher(path).find();
+        }
+    }
+}
-- 
cgit v1.2.3