Java tutorial
/* * Sonar Web Plugin * Copyright (C) 2010 Matthijs Galesloot * dev@sonar.codehaus.org * * 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. */ package org.sonar.plugins.web.api; import java.io.File; import java.io.IOException; import java.util.ArrayList; import java.util.Arrays; import java.util.List; import org.apache.commons.io.FileUtils; import org.apache.commons.io.FilenameUtils; import org.apache.commons.io.filefilter.AndFileFilter; import org.apache.commons.io.filefilter.FileFilterUtils; import org.apache.commons.io.filefilter.HiddenFileFilter; import org.apache.commons.io.filefilter.IOFileFilter; import org.apache.commons.io.filefilter.SuffixFileFilter; import org.apache.commons.lang.StringUtils; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.sonar.api.resources.InputFile; import org.sonar.api.resources.Project; import org.sonar.api.utils.SonarException; import org.sonar.api.utils.WildcardPattern; import org.sonar.plugins.web.language.Web; import com.google.common.collect.Lists; /** * Provide list of sourcefiles and dirs in scope for the WebPlugin. * * @author Matthijs * @since 1.1 */ public class ProjectFileManager { private static class ExclusionFilter implements IOFileFilter { private final WildcardPattern[] patterns; private final File sourceDir; ExclusionFilter(File sourceDir, WildcardPattern[] patterns) { this.sourceDir = sourceDir; this.patterns = patterns; } public boolean accept(File file) { String relativePath = getRelativePath(file, sourceDir); if (relativePath == null) { return false; } for (WildcardPattern pattern : patterns) { if (pattern.match(relativePath)) { return false; } } return true; } public boolean accept(File file, String name) { return accept(file); } } private static final class WebInputFile implements InputFile { private final File basedir; private final String relativePath; WebInputFile(File basedir, String relativePath) { this.basedir = basedir; this.relativePath = relativePath; } public File getFile() { return new File(basedir, relativePath); } public File getFileBaseDir() { return basedir; } public String getRelativePath() { return relativePath; } } private static final Logger LOG = LoggerFactory.getLogger(ProjectFileManager.class); private static boolean containsFile(List<File> dirs, File cursor) { for (File dir : dirs) { if (FilenameUtils.equalsNormalizedOnSystem(dir.getAbsolutePath(), cursor.getAbsolutePath())) { return true; } } return false; } /** * getRelativePath("c:/foo/src/my/package/Hello.java", "c:/foo/src") is "my/package/Hello.java" * * @return null if file is not in dir (including recursive subdirectories) */ public static String getRelativePath(File file, File dir) { return getRelativePath(file, Arrays.asList(dir)); } /** * getRelativePath("c:/foo/src/my/package/Hello.java", ["c:/bar", "c:/foo/src"]) is "my/package/Hello.java". * <p> * Relative path is composed of slashes. Windows backslaches are replaced by / * </p> * * @return null if file is not in dir (including recursive subdirectories) */ public static String getRelativePath(File file, List<File> dirs) { List<String> stack = new ArrayList<String>(); String path = FilenameUtils.normalize(file.getAbsolutePath()); File cursor = new File(path); while (cursor != null) { if (containsFile(dirs, cursor)) { return StringUtils.join(stack, "/"); } stack.add(0, cursor.getName()); cursor = cursor.getParentFile(); } return null; } private final List<IOFileFilter> filters = Lists.newArrayList(); private final Project project; private final List<File> sourceDirs; public ProjectFileManager(Project project) { this.project = project; sourceDirs = compileSourceDirs(); } /** * Gets list of source dirs. First checks configuration setting for "sonar.web.sourceDirectory". Next the project source directory will be * tried. */ private List<File> compileSourceDirs() { List<File> dirs = new ArrayList<File>(); Object property = project.getProperty(WebConstants.SOURCE_DIRECTORY); if (property != null) { if (property instanceof ArrayList) { for (Object configuredDir : (List) property) { dirs.add(resolvePath((String) configuredDir)); } } else { dirs.add(resolvePath((String) property)); } } else { if (project.getFileSystem() != null) { dirs.addAll(project.getFileSystem().getSourceDirs()); } } // check if the source dirs exist for (File dir : new ArrayList<File>(dirs)) { if (dir.exists()) { LOG.info("Source dir for web files: " + dir.getPath()); } else { LOG.error("Could not find source dir: " + dir.getPath()); dirs.remove(dir); } } return dirs; } public org.sonar.api.resources.File fromIOFile(InputFile inputfile) { org.sonar.api.resources.File file = org.sonar.api.resources.File.fromIOFile(inputfile.getFile(), sourceDirs); file.setLanguage(Web.INSTANCE); return file; } public File getBasedir() { return project.getFileSystem().getBasedir(); } private WildcardPattern[] getExclusionPatterns(boolean applyExclusionPatterns) { WildcardPattern[] exclusionPatterns; if (applyExclusionPatterns) { exclusionPatterns = WildcardPattern.create(project.getExclusionPatterns()); } else { exclusionPatterns = new WildcardPattern[0]; } return exclusionPatterns; } /** * Gets the list of files that are in scope for importing and analysis. */ public List<InputFile> getFiles() { List<InputFile> result = Lists.newArrayList(); IOFileFilter suffixFilter = getFileSuffixFilter(); WildcardPattern[] exclusionPatterns = getExclusionPatterns(true); IOFileFilter visibleFileFilter = HiddenFileFilter.VISIBLE; for (File dir : sourceDirs) { if (dir.exists()) { // exclusion filter IOFileFilter exclusionFilter = new ExclusionFilter(dir, exclusionPatterns); // visible filter List<IOFileFilter> fileFilters = Lists.newArrayList(visibleFileFilter, suffixFilter, exclusionFilter); fileFilters.addAll(this.filters); // create DefaultInputFile for each file. List<File> files = (List<File>) FileUtils.listFiles(dir, new AndFileFilter(fileFilters), HiddenFileFilter.VISIBLE); for (File file : files) { String relativePath = getRelativePath(file, dir); result.add(new WebInputFile(dir, relativePath)); } } } return result; } public String[] getFileSuffixes() { List<?> extensions = project.getConfiguration().getList(WebConstants.FILE_EXTENSIONS); if (extensions != null && !extensions.isEmpty() && !StringUtils.isEmpty((String) extensions.get(0))) { String[] fileSuffixes = new String[extensions.size()]; for (int i = 0; i < extensions.size(); i++) { fileSuffixes[i] = extensions.get(i).toString().trim(); } return fileSuffixes; } else { return Web.INSTANCE.getFileSuffixes(); } } private IOFileFilter getFileSuffixFilter() { IOFileFilter suffixFilter = FileFilterUtils.trueFileFilter(); List<String> suffixes = Arrays.asList(getFileSuffixes()); if (!suffixes.isEmpty()) { suffixFilter = new SuffixFileFilter(suffixes); } return suffixFilter; } public List<File> getSourceDirs() { return sourceDirs; } public File resolvePath(String path) { File file = new File(path); if (!file.isAbsolute()) { try { file = new File(getBasedir(), path).getCanonicalFile(); } catch (IOException e) { throw new SonarException("Unable to resolve path '" + path + "'", e); } } return file; } }