Clarify overall project structure.

[gpl/argeo-slc.git] / legacy / org.argeo.slc.spring / src / org / argeo / slc / core / deploy / DefaultResourceSet.java

diff --git a/legacy/org.argeo.slc.spring/src/org/argeo/slc/core/deploy/DefaultResourceSet.java b/legacy/org.argeo.slc.spring/src/org/argeo/slc/core/deploy/DefaultResourceSet.java
new file mode 100644 (file)
index 0000000..a5b8536
--- /dev/null
+++ b/legacy/org.argeo.slc.spring/src/org/argeo/slc/core/deploy/DefaultResourceSet.java
@@ -0,0 +1,171 @@
+package org.argeo.slc.core.deploy;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.StringTokenizer;
+import java.util.TreeMap;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.argeo.slc.SlcException;
+import org.springframework.beans.factory.InitializingBean;
+import org.springframework.context.ResourceLoaderAware;
+import org.springframework.core.io.Resource;
+import org.springframework.core.io.ResourceLoader;
+import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
+import org.springframework.core.io.support.ResourcePatternResolver;
+import org.springframework.util.AntPathMatcher;
+import org.springframework.util.PathMatcher;
+
+public class DefaultResourceSet implements ResourceLoaderAware,
+               InitializingBean, ResourceSet {
+       private final static Log log = LogFactory.getLog(DefaultResourceSet.class);
+       public final static String DEFAULT_EXCLUDES = "**/.svn/**";
+
+       private String base;
+       private String include;
+       private List<String> includes = new ArrayList<String>();
+       private String exclude;
+       private List<String> excludes = new ArrayList<String>();
+       private Boolean useDefaultExcludes = true;
+       private ResourcePatternResolver resourcePatternResolver;
+       private PathMatcher excludePathMatcher = new AntPathMatcher();
+
+       private ResourceLoader resourceLoader;
+
+       /** List the resources, identified by their relative path. */
+       public Map<String, Resource> listResources() {
+               try {
+                       Map<String, Resource> res = new TreeMap<String, Resource>();
+                       if (base == null)
+                               return res;
+                       String baseResUrl = getResourceLoaderToUse().getResource(base)
+                                       .getURL().toString();
+                       for (String includePattern : includes)
+                               processInclude(res, includePattern, baseResUrl);
+                       return res;
+               } catch (IOException e) {
+                       throw new SlcException("Cannot list resource from " + base, e);
+               }
+       }
+
+       protected void processInclude(Map<String, Resource> res, String include,
+                       String baseResUrl) throws IOException {
+               String pattern = base + "/" + include;
+               if (log.isTraceEnabled())
+                       log.trace("Look for resources with pattern '" + pattern
+                                       + "' in base url " + baseResUrl);
+               Resource[] resources = resourcePatternResolver.getResources(pattern);
+               resources: for (Resource resource : resources) {
+                       String url = resource.getURL().toString();
+                       String relPath = url.substring(baseResUrl.length());
+
+                       // skip dir
+                       if (relPath.charAt(relPath.length() - 1) == '/') {
+                               if (log.isTraceEnabled())
+                                       log.trace("Skip directory " + relPath + "=" + resource);
+                               continue resources;
+                       }
+
+                       // make sure there is not starting '/'
+                       if (relPath.charAt(0) == '/')
+                               relPath = relPath.substring(1);
+
+                       // skip excludes
+                       for (String exclude : excludes)
+                               if (excludePathMatcher.match(exclude, relPath)) {
+                                       if (log.isTraceEnabled())
+                                               log.trace("Exclude " + relPath + "=" + resource);
+                                       continue resources;
+                               }
+
+                       // check if already exists
+                       if (res.containsKey(relPath))
+                               log.warn(relPath + " already matched by " + res.get(relPath)
+                                               + ", " + resource + " will override it.");
+
+                       // store the marched resource
+                       res.put(relPath, resource);
+                       if (log.isTraceEnabled())
+                               log.trace(relPath + "=" + resource);
+               }
+
+       }
+
+       public void afterPropertiesSet() throws Exception {
+               if (resourcePatternResolver == null)
+                       resourcePatternResolver = new PathMatchingResourcePatternResolver(
+                                       getResourceLoaderToUse());
+               if (include != null)
+                       addCommaSeparatedToList(include, includes);
+               if (exclude != null)
+                       addCommaSeparatedToList(exclude, excludes);
+
+               if (includes.size() == 0)
+                       includes.add("**");
+
+               if (useDefaultExcludes)
+                       addCommaSeparatedToList(DEFAULT_EXCLUDES, excludes);
+       }
+
+       private void addCommaSeparatedToList(String str, List<String> lst) {
+               StringTokenizer st = new StringTokenizer(str, ",");
+               while (st.hasMoreTokens()) {
+                       String token = st.nextToken();
+                       if (!lst.contains(token))
+                               lst.add(token);
+               }
+       }
+
+       public void setResourceLoader(ResourceLoader resourceLoader) {
+               this.resourceLoader = resourceLoader;
+       }
+
+       /**
+        * Can be overridden in order to provide the proper resource loader used to
+        * resolve resources.
+        */
+       public ResourceLoader getResourceLoaderToUse() {
+               return resourceLoader;
+       }
+
+       public void setBase(String base) {
+               this.base = base;
+       }
+
+       public void setInclude(String include) {
+               this.include = include;
+       }
+
+       public void setIncludes(List<String> includes) {
+               this.includes = includes;
+       }
+
+       public void setExclude(String exclude) {
+               this.exclude = exclude;
+       }
+
+       public void setExcludes(List<String> excludes) {
+               this.excludes = excludes;
+       }
+
+       public void setUseDefaultExcludes(Boolean useDefaultExcludes) {
+               this.useDefaultExcludes = useDefaultExcludes;
+       }
+
+       public void setExcludePathMatcher(PathMatcher excludePathMatcher) {
+               this.excludePathMatcher = excludePathMatcher;
+       }
+
+       public void setResourcePatternResolver(
+                       ResourcePatternResolver resourcePatternResolver) {
+               this.resourcePatternResolver = resourcePatternResolver;
+       }
+
+       public ResourcePatternResolver getResourcePatternResolver() {
+               return resourcePatternResolver;
+       }
+
+}