Export did not manage case differences (mode vs. Mode) 11/4111/1
authorAntti Villberg <antti.villberg@semantum.fi>
Fri, 10 Apr 2020 17:18:53 +0000 (20:18 +0300)
committerAntti Villberg <antti.villberg@semantum.fi>
Fri, 10 Apr 2020 17:18:53 +0000 (20:18 +0300)
gitlab #452

Change-Id: I8d4d8908c2dc14ac50c0d7544f7886317689098e

bundles/org.simantics.modeling/src/org/simantics/modeling/utils/DumpOntologyStructure.java

index 5bb3d9ca21c95d30bb5d96200d41caade8bf59df..e058f2c36fed2fb0ba8d6753c5fd47a244aa4963 100644 (file)
@@ -5,7 +5,9 @@ import java.io.IOException;
 import java.nio.charset.StandardCharsets;
 import java.util.Collection;
 import java.util.HashMap;
 import java.nio.charset.StandardCharsets;
 import java.util.Collection;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.Map;
 import java.util.Map;
+import java.util.Set;
 import java.util.TreeMap;
 
 import org.simantics.Simantics;
 import java.util.TreeMap;
 
 import org.simantics.Simantics;
@@ -32,17 +34,48 @@ public class DumpOntologyStructure {
     private Resource ontology;
 
     private Map<Resource, String> names = new HashMap<>();
     private Resource ontology;
 
     private Map<Resource, String> names = new HashMap<>();
-    private Map<Resource,Resource> parents = new HashMap<>();
+    private Map<Resource,Resource> parents = new TreeMap<>();
     private Map<Resource, File> libraryFolders = new HashMap<>();
     private Map<Resource, byte[]> contentDumps = new HashMap<>();
 
     private void readNameAndParent(ReadGraph graph, Resource container, Resource r) throws DatabaseException {
     private Map<Resource, File> libraryFolders = new HashMap<>();
     private Map<Resource, byte[]> contentDumps = new HashMap<>();
 
     private void readNameAndParent(ReadGraph graph, Resource container, Resource r) throws DatabaseException {
+        String name = NameUtils.getSafeName(graph, r);
         parents.put(r, container);
         parents.put(r, container);
-        names.put(r, NameUtils.getSafeName(graph, r));
+        names.put(r, FileUtils.escapeFileName(name));
     }
 
     }
 
-    private Collection<Resource> containers() {
-        return parents.values();
+    /*
+     * This shall return containers sorted by full path.
+     * This makes processing order stable and ensures that
+     * directories are processed before their contents. 
+     */
+    private Collection<Resource> sortedContainers(File rootFolder) {
+        Set<Resource> parentSet = new HashSet<Resource>(parents.values());
+        TreeMap<String,Resource> result = new TreeMap<>();
+        for(Resource r : parentSet) {
+            File f = getFolder(rootFolder, r);
+            result.put(f.getAbsolutePath(), r);
+        }
+        return result.values();
+    }
+
+    private Collection<Resource> sortedResources(File rootFolder) {
+        TreeMap<String,Resource> result = new TreeMap<>();
+        for(Resource r : parents.keySet()) {
+            byte[] dump = contentDumps.get(r);
+            if(dump == null)
+                dump = "".getBytes(StandardCharsets.UTF_8);
+            if(isParent(r)) {
+                if(dump.length > 0) {
+                    File f = new File(getFolder(rootFolder, r), "__contents__");
+                    result.put(f.getAbsolutePath(), r);
+                }
+            } else {
+                File f = getFile(rootFolder, r);
+                result.put(f.getAbsolutePath(), r);
+            }
+        }
+        return result.values();
     }
 
     private void readHierarchy(ReadGraph graph, Resource container) throws DatabaseException {
     }
 
     private void readHierarchy(ReadGraph graph, Resource container) throws DatabaseException {
@@ -110,37 +143,56 @@ public class DumpOntologyStructure {
     public void write(File unsafeFolder) throws IOException {
         File folder = escapeFile(unsafeFolder);
         FileUtils.delete(folder.toPath());
     public void write(File unsafeFolder) throws IOException {
         File folder = escapeFile(unsafeFolder);
         FileUtils.delete(folder.toPath());
-        folder.mkdirs();
+        folder.getParentFile().mkdirs();
         writeDirectories(folder);
         writeResources(folder);
     }
 
         writeDirectories(folder);
         writeResources(folder);
     }
 
+    Resource getParent(Resource r) {
+        return parents.get(r);
+    }
+    
     private File getFolder(File root, Resource library) {
         if(ontology.equals(library))
             return root;
     private File getFolder(File root, Resource library) {
         if(ontology.equals(library))
             return root;
-        Resource parent = parents.get(library);
+        Resource parent = getParent(library);
         if(parent == null)
             throw new IllegalStateException("null parent for " + library);
         File parentFolder = getFolder(root, parent);
         if(parent == null)
             throw new IllegalStateException("null parent for " + library);
         File parentFolder = getFolder(root, parent);
-        return new File(parentFolder, FileUtils.escapeFileName(names.get(library))); 
+        return new File(parentFolder, names.get(library)); 
     }
 
     private File getFile(File rootFolder, Resource r) {
     }
 
     private File getFile(File rootFolder, Resource r) {
-        Resource parent = parents.get(r);
+        Resource parent = getParent(r);
         File folder = getFolder(rootFolder, parent);
         File folder = getFolder(rootFolder, parent);
-        return new File(folder, FileUtils.escapeFileName(names.get(r)));
+        return new File(folder, names.get(r));
     }
 
     }
 
+    private File makeUnique(File original, Resource r) {
+        int counter = 2;
+        File file = new File(original.getParent(), original.getName());
+        File test = file;
+        while(test.exists()) {
+            // Here we have a name clash with small and big letters! (windows)
+            test = new File(file.getParent(), file.getName() + "____" + (counter++));
+        }
+        // Enforce this renaming in future operations also
+        names.put(r, test.getName());
+        return test;
+    }
+    
     private void writeDirectories(File rootFolder) {
     private void writeDirectories(File rootFolder) {
-        for(Resource library : containers()) {
-            File folder = getFolder(rootFolder, library);
+        // Here stuff shall be returned in alphabetical order
+        for(Resource library : sortedContainers(rootFolder)) {
+            File folder = makeUnique(getFolder(rootFolder, library), library);
             folder.mkdirs();
             libraryFolders.put(library, folder);
         }
     }
 
     private void writeResources(File rootFolder) throws IOException {
             folder.mkdirs();
             libraryFolders.put(library, folder);
         }
     }
 
     private void writeResources(File rootFolder) throws IOException {
-        for(Resource r : parents.keySet()) {
+        // Here stuff shall be returned in alphabetical order
+        for(Resource r : sortedResources(rootFolder)) {
             writeResource(rootFolder, r);
         }
     }
             writeResource(rootFolder, r);
         }
     }
@@ -162,7 +214,7 @@ public class DumpOntologyStructure {
     }
 
     private void write(File rootFolder, Resource resource, byte[] bytes) throws IOException {
     }
 
     private void write(File rootFolder, Resource resource, byte[] bytes) throws IOException {
-        FileUtils.writeFile(getFile(rootFolder, resource), bytes);
+        FileUtils.writeFile(makeUnique(getFile(rootFolder, resource), resource), bytes);
     }
 
 }
\ No newline at end of file
     }
 
 }
\ No newline at end of file