X-Git-Url: http://git.argeo.org/?a=blobdiff_plain;f=legacy%2Forg.argeo.slc.spring%2Fsrc%2Forg%2Fargeo%2Fslc%2Fcore%2Fdeploy%2FDefaultResourceSet.java;fp=legacy%2Forg.argeo.slc.spring%2Fsrc%2Forg%2Fargeo%2Fslc%2Fcore%2Fdeploy%2FDefaultResourceSet.java;h=a5b8536df8649d1e181c5e1dcbf77a92ea8422d9;hb=6fc94d69efe089414ac9e63bde3efab1cbf7b7ca;hp=0000000000000000000000000000000000000000;hpb=b36c62642bd0db11b3133b369cc026fd4b7a1ec6;p=gpl%2Fargeo-slc.git

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
index 000000000..a5b8536df
--- /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;
+	}
+
+}