//------------------------------------------------------------------------------
// Copyright (c) 2005, 2006 IBM Corporation and others.
// All rights reserved. This program and the accompanying materials
// are made available under the terms of the Eclipse Public License v1.0
// which accompanies this distribution, and is available at
// http://www.eclipse.org/legal/epl-v10.html
//
// Contributors:
// IBM Corporation - initial implementation
//------------------------------------------------------------------------------
package org.eclipse.epf.importing.services;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.eclipse.epf.common.utils.FileUtil;
import org.eclipse.epf.common.utils.NetUtil;
import org.eclipse.epf.library.ILibraryResourceManager;
import org.eclipse.epf.library.util.ResourceHelper;
import org.eclipse.epf.uma.MethodElement;
import org.eclipse.epf.uma.MethodPlugin;
/**
* utility class to scan and copy resources from the source library to the target library
* @author Jinhua Xi
* @since 1.0
*
*/
public class ResourceScanner {
public static final Pattern p_src_ref = Pattern.compile("src\\s*=\\s*\"(.*?)\"", Pattern.CASE_INSENSITIVE | Pattern.DOTALL); //$NON-NLS-1$
// protected static final Pattern p_link_ref = Pattern.compile("<a\\s+?([^>]*)>(.*?)</a>", Pattern.CASE_INSENSITIVE | Pattern.DOTALL); //$NON-NLS-1$
public static final Pattern p_href_ref = Pattern.compile("href\\s*=\\s*\"(.*?)\"", Pattern.CASE_INSENSITIVE | Pattern.DOTALL); //$NON-NLS-1$
File srcLibRoot;
File targetLibRoot;
private Map newFileMap = new HashMap();
private Map existingFileMap = new HashMap();
Map<String, String> renamePluginMap;
/**
* Creates a new instance.
*/
public ResourceScanner(File srcLibRoot, File targetLibRoot, Map<String, String> renamePluginMap) {
this.srcLibRoot = srcLibRoot;
this.targetLibRoot = targetLibRoot;
this.renamePluginMap = renamePluginMap;
}
/**
* scan th etext and copy the resources
* @param owner MethodElement
* @param source String
*/
public void scan(MethodElement owner, String source) {
try
{
// process images and other src resources
Matcher m = p_src_ref.matcher(source);
while ( m.find() )
{
String url = m.group(1);
processUrl(owner, url);
}
// process hrefs
m = p_href_ref.matcher(source);
while ( m.find() )
{
String url = m.group(1);
processUrl(owner, url);
}
}
catch (Exception ex)
{
ex.printStackTrace();
}
}
/**
* process the url and copy the resource
* if the owner element is specified, the url is relative to the owner element,
*otherwise it's relative to the library
*
* @param owner
* @param url
*/
private void processUrl(MethodElement owner, String url) {
processUrl(owner, url, null);
}
private void processUrl(MethodElement owner, String url, MethodPlugin plugin) {
if ( url == null ) {
return;
}
int index = url.indexOf("#"); //$NON-NLS-1$
if ( index >= 0 )
{
url = url.substring(0, index);
}
index = url.indexOf("?"); //$NON-NLS-1$
if ( index >= 0 )
{
url = url.substring(0, index);
}
if (url.trim().length() == 0 ) {
return;
}
// the url is relative to the owner element
// need to convert to the path relative to the library root
File srcFile = null;
File targetFile = null;
try {
if ( owner != null ) {
ILibraryResourceManager libResMgr = ResourceHelper.getResourceMgr(owner);
String elementPath = ResourceHelper.getElementPath(owner);
//srcFile = new File(new File(srcLibRoot, elementPath), url);
//if (!srcFile.isFile() || !srcFile.exists()) {
elementPath = getElementPathWithRenamedPlugin(elementPath);
srcFile = new File(new File(srcLibRoot, elementPath), url);
//}
if (!srcFile.isFile() || !srcFile.exists()) {
url = NetUtil.decodeURL(url);
srcFile = new File(new File(srcLibRoot, elementPath), url);
}
//targetFile = new File(new File(targetLibRoot, elementPath), url);
String pluginPath = libResMgr.getPhysicalPluginPath(owner);
File targetRoot = (new File(pluginPath)).getParentFile();
targetFile = new File(new File(targetRoot, elementPath), url);
} else {
if (plugin == null) {
throw new UnsupportedOperationException();
}
File srcPluginRoot = new File(srcLibRoot, plugin.getName());
srcFile = new File(srcPluginRoot, url);
if (!srcFile.isFile() || !srcFile.exists()) {
url = NetUtil.decodeURL(url);
srcFile = new File(srcPluginRoot, url);
}
ILibraryResourceManager libResMgr = ResourceHelper.getResourceMgr(plugin);
String srcPluginRootPath = libResMgr.getPhysicalPluginPath(plugin);
targetFile = new File(srcPluginRootPath, url);
}
if ( srcFile.isFile() && srcFile.exists() ) {
srcFile = srcFile.getCanonicalFile();
targetFile = targetFile.getCanonicalFile();
if ( targetFile.exists() ) {
if ( !existingFileMap.containsKey(srcFile) ) {
if ( srcFile.length() != targetFile.length()
|| srcFile.lastModified() != targetFile.lastModified() )
{
existingFileMap.put(srcFile, targetFile);
}
}
} else {
if ( !newFileMap.containsKey(srcFile) ) {
newFileMap.put(srcFile, targetFile);
}
}
}
} catch (IOException e) {
// Log the error and proceed. TODO
e.printStackTrace();
}
}
private String getElementPathWithRenamedPlugin(String elementPath) {
if (renamePluginMap != null && ! renamePluginMap.isEmpty()) {
int ix = elementPath.indexOf("\\");//$NON-NLS-1$
if (ix > 0) {
String basePluginName = elementPath.substring(0, ix);
String importPluginName = renamePluginMap.get(basePluginName);
if (importPluginName != null) {
return importPluginName + elementPath.substring(ix);
}
}
}
return elementPath;
}
/**
* Copies resource.
*/
public void copyResource(String url, MethodPlugin plugin) {
processUrl(null, url, plugin);
}
/**
* Copies resource.
*/
public void copyResource(MethodElement owner, String url) {
processUrl(owner, url);
}
/**
* return a list of all the files to be replaced
* @return List a list of file path string
*/
public List getFilesTobeReplaced() {
List files = new ArrayList();
if ( existingFileMap.size() > 0 ) {
for (Iterator it = existingFileMap.values().iterator(); it.hasNext(); ) {
File f = (File)it.next();
if (f != null ) {
String path = f.getAbsolutePath();
if ( !files.contains(path) ) {
files.add(path);
}
}
}
}
return files;
}
/**
* copy all the files to the destination
*
*/
public void execute() {
for (Iterator it = newFileMap.entrySet().iterator(); it.hasNext(); ) {
Map.Entry entry = (Map.Entry)it.next();
File srcFile = (File) entry.getKey();
File targetFile = (File) entry.getValue();
FileUtil.copyFile(srcFile, targetFile);
}
for (Iterator it = existingFileMap.entrySet().iterator(); it.hasNext(); ) {
Map.Entry entry = (Map.Entry)it.next();
File srcFile = (File) entry.getKey();
File targetFile = (File) entry.getValue();
FileUtil.copyFile(srcFile, targetFile);
}
}
}