package org.sonar.api.batch.fs;
import java.io.File;
+import java.net.URI;
import java.util.Collection;
/**
*/
FilePredicate hasExtension(String s);
+ /**
+ * Predicate that gets a file by its {@link InputFile#uri()}.
+ *
+ * @since 6.6
+ */
+ FilePredicate hasURI(URI uri);
+
/**
* Predicate that gets the files which relative or absolute path matches a wildcard pattern.
* <br>
*/
package org.sonar.api.batch.fs.internal;
-import org.sonar.api.batch.fs.FilePredicate;
-import org.sonar.api.batch.fs.FilePredicates;
-import org.sonar.api.batch.fs.InputFile;
-
import java.io.File;
+import java.net.URI;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
+import org.sonar.api.batch.fs.FilePredicate;
+import org.sonar.api.batch.fs.FilePredicates;
+import org.sonar.api.batch.fs.InputFile;
/**
* Factory of {@link org.sonar.api.batch.fs.FilePredicate}
return new FilenamePredicate(s);
}
- @Override public FilePredicate hasExtension(String s) {
+ @Override
+ public FilePredicate hasExtension(String s) {
return new FileExtensionPredicate(s);
}
+ @Override
+ public FilePredicate hasURI(URI uri) {
+ return new URIPredicate(uri, baseDir);
+ }
+
@Override
public FilePredicate matchesPathPattern(String inclusionPattern) {
return new PathPatternPredicate(PathPattern.create(inclusionPattern));
languages.add(inputFile.language());
}
fileMap.put(inputFile.relativePath(), inputFile);
- filesByNameCache.put(FilenamePredicate.getFilename(inputFile), inputFile);
+ filesByNameCache.put(inputFile.filename(), inputFile);
filesByExtensionCache.put(FileExtensionPredicate.getExtension(inputFile), inputFile);
}
}
public static String getExtension(InputFile inputFile) {
- return getExtension(FilenamePredicate.getFilename(inputFile));
+ return getExtension(inputFile.filename());
}
static String getExtension(String name) {
@Override
public boolean apply(InputFile inputFile) {
- return filename.equals(getFilename(inputFile));
+ return filename.equals(inputFile.filename());
}
@Override
return index.getFilesByName(filename);
}
- public static String getFilename(InputFile inputFile) {
- return inputFile.file().getName();
- }
}
--- /dev/null
+/*
+ * SonarQube
+ * Copyright (C) 2009-2017 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+package org.sonar.api.batch.fs.internal;
+
+import java.net.URI;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Arrays;
+import java.util.Collections;
+import org.sonar.api.batch.fs.FileSystem.Index;
+import org.sonar.api.batch.fs.InputFile;
+import org.sonar.api.scan.filesystem.PathResolver;
+import org.sonar.api.utils.PathUtils;
+
+/**
+ * @since 6.6
+ */
+class URIPredicate extends AbstractFilePredicate {
+
+ private final URI uri;
+ private final Path baseDir;
+
+ URIPredicate(URI uri, Path baseDir) {
+ this.baseDir = baseDir;
+ this.uri = uri;
+ }
+
+ @Override
+ public boolean apply(InputFile f) {
+ return uri.equals(f.uri());
+ }
+
+ @Override
+ public Iterable<InputFile> get(Index index) {
+ Path path = Paths.get(uri);
+ String relative = PathUtils.sanitize(PathResolver.relativePath(baseDir, path));
+ if (relative == null) {
+ return Collections.emptyList();
+ }
+ InputFile f = index.inputFile(relative);
+ return f != null ? Arrays.asList(f) : Collections.<InputFile>emptyList();
+ }
+
+ @Override
+ public int priority() {
+ return USE_INDEX;
+ }
+}
*/
package org.sonar.api.batch.fs.internal;
+import java.io.File;
+import java.io.IOException;
+import java.net.URI;
+import java.nio.file.Path;
+import java.util.Arrays;
+import java.util.Collections;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.batch.fs.FilePredicates;
import org.sonar.api.batch.fs.InputFile;
-import java.io.File;
-import java.io.IOException;
-import java.nio.file.Path;
-import java.util.Arrays;
-import java.util.Collections;
-
import static org.assertj.core.api.Assertions.assertThat;
public class DefaultFilePredicatesTest {
.setModuleBaseDir(moduleBasePath)
.setLanguage("java")
.build();
+
}
@Test
assertThat(predicates.hasAbsolutePath("src/main/java/struts/Action.java").apply(javaFile)).isFalse();
}
+ @Test
+ public void has_uri() throws Exception {
+ URI uri = javaFile.uri();
+ assertThat(predicates.hasURI(uri).apply(javaFile)).isTrue();
+
+ assertThat(predicates.hasURI(temp.newFile().toURI()).apply(javaFile)).isFalse();
+ }
+
@Test
public void has_path() throws Exception {
// is relative path
assertThat(fs.inputFile(fs.predicates().hasRelativePath("src/Bar.java"))).isNotNull();
assertThat(fs.inputFile(fs.predicates().hasRelativePath("does/not/exist"))).isNull();
+ assertThat(fs.inputFile(fs.predicates().hasAbsolutePath(new File(basedir, "src/Bar.java").getAbsolutePath()))).isNotNull();
+ assertThat(fs.inputFile(fs.predicates().hasAbsolutePath(new File(basedir, "does/not/exist").getAbsolutePath()))).isNull();
+ assertThat(fs.inputFile(fs.predicates().hasAbsolutePath(new File(basedir, "../src/Bar.java").getAbsolutePath()))).isNull();
+
+ assertThat(fs.inputFile(fs.predicates().hasURI(new File(basedir, "src/Bar.java").toURI()))).isNotNull();
+ assertThat(fs.inputFile(fs.predicates().hasURI(new File(basedir, "does/not/exist").toURI()))).isNull();
+ assertThat(fs.inputFile(fs.predicates().hasURI(new File(basedir, "../src/Bar.java").toURI()))).isNull();
+
assertThat(fs.files(fs.predicates().all())).hasSize(4);
assertThat(fs.files(fs.predicates().hasLanguage("java"))).hasSize(2);
assertThat(fs.files(fs.predicates().hasLanguage("cobol"))).isEmpty();
*/
package org.sonar.api.batch.fs.internal;
-import java.io.File;
import java.io.IOException;
-import org.junit.*;
+import org.junit.Test;
import org.sonar.api.batch.fs.InputFile;
import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.*;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
import static org.sonar.api.batch.fs.internal.FileExtensionPredicate.getExtension;
public class FileExtensionPredicateTest {
private InputFile mockWithName(String filename) throws IOException {
InputFile inputFile = mock(InputFile.class);
- when(inputFile.file()).thenReturn(new File("dummy parent", filename));
+ when(inputFile.filename()).thenReturn(filename);
return inputFile;
}
}
*/
package org.sonar.api.batch.fs.internal;
-import java.io.File;
import java.io.IOException;
import java.util.Collections;
-import org.junit.*;
+import org.junit.Test;
import org.sonar.api.batch.fs.FileSystem;
import org.sonar.api.batch.fs.InputFile;
import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.*;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
public class FilenamePredicateTest {
@Test
public void should_match_file_by_filename() throws IOException {
String filename = "some name";
InputFile inputFile = mock(InputFile.class);
- when(inputFile.file()).thenReturn(newDummyFile(filename));
+ when(inputFile.filename()).thenReturn(filename);
assertThat(new FilenamePredicate(filename).apply(inputFile)).isTrue();
}
public void should_not_match_file_by_different_filename() throws IOException {
String filename = "some name";
InputFile inputFile = mock(InputFile.class);
- when(inputFile.file()).thenReturn(newDummyFile(filename + "x"));
+ when(inputFile.filename()).thenReturn(filename + "x");
assertThat(new FilenamePredicate(filename).apply(inputFile)).isFalse();
}
public void should_find_matching_file_in_index() throws IOException {
String filename = "some name";
InputFile inputFile = mock(InputFile.class);
- when(inputFile.file()).thenReturn(newDummyFile(filename));
+ when(inputFile.filename()).thenReturn(filename);
FileSystem.Index index = mock(FileSystem.Index.class);
when(index.getFilesByName(filename)).thenReturn(Collections.singleton(inputFile));
assertThat(new FilenamePredicate(filename).get(index)).containsOnly(inputFile);
}
- private File newDummyFile(String filename) {
- return new File("dummy parent", filename);
- }
}
}
String parentRelativePath = getParentRelativePath(inputFile);
synchronized (this) {
- indexParentDir(inputFile, parentRelativePath);
+ indexFileAndParentDir(inputFile, parentRelativePath);
progress.markAsIndexed(inputFile);
}
LOG.debug("'{}' indexed {}with language '{}'", relativePathStr, type == Type.TEST ? "as test " : "", inputFile.language());
return relativePath;
}
- private void indexParentDir(InputFile inputFile, String parentRelativePath) {
+ private void indexFileAndParentDir(InputFile inputFile, String parentRelativePath) {
DefaultInputDir inputDir = (DefaultInputDir) componentStore.getDir(module.key(), parentRelativePath);
if (inputDir == null) {
inputDir = new DefaultInputDir(module.key(), parentRelativePath, batchIdGenerator.get());
import org.sonar.api.batch.fs.internal.DefaultInputFile;
import org.sonar.api.batch.fs.internal.DefaultInputModule;
import org.sonar.api.batch.fs.internal.FileExtensionPredicate;
-import org.sonar.api.batch.fs.internal.FilenamePredicate;
import org.sonar.api.scan.filesystem.PathResolver;
/**
@ScannerSide
public class InputComponentStore {
- private final PathResolver pathResolver;
private final SortedSet<String> globalLanguagesCache = new TreeSet<>();
private final Map<String, SortedSet<String>> languagesCache = new HashMap<>();
private final Map<String, InputFile> globalInputFileCache = new HashMap<>();
private final SetMultimap<String, InputFile> filesByExtensionCache = LinkedHashMultimap.create();
private final InputModule root;
- public InputComponentStore(PathResolver pathResolver, DefaultInputModule root) {
- this.pathResolver = pathResolver;
+ public InputComponentStore(DefaultInputModule root) {
this.root = root;
this.put(root);
}
inputFileCache.put(file.moduleKey(), inputFile.relativePath(), inputFile);
globalInputFileCache.put(getProjectRelativePath(file), inputFile);
inputComponents.put(inputFile.key(), inputFile);
- filesByNameCache.put(FilenamePredicate.getFilename(inputFile), inputFile);
+ filesByNameCache.put(inputFile.filename(), inputFile);
filesByExtensionCache.put(FileExtensionPredicate.getExtension(inputFile), inputFile);
return this;
}
}
private String getProjectRelativePath(DefaultInputFile file) {
- return pathResolver.relativePath(getProjectBaseDir(), file.path());
+ return PathResolver.relativePath(getProjectBaseDir(), file.path());
}
private String getProjectRelativePath(DefaultInputDir dir) {
- return pathResolver.relativePath(getProjectBaseDir(), dir.path());
+ return PathResolver.relativePath(getProjectBaseDir(), dir.path());
}
private Path getProjectBaseDir() {
import org.picocontainer.injectors.ProviderAdapter;
import org.sonar.api.batch.fs.internal.InputModuleHierarchy;
-import org.sonar.api.scan.filesystem.PathResolver;
public class InputComponentStoreProvider extends ProviderAdapter {
private InputComponentStore store;
- public InputComponentStore provide(PathResolver pathResolver, InputModuleHierarchy hierarchy) {
+ public InputComponentStore provide(InputModuleHierarchy hierarchy) {
if (store == null) {
- store = new InputComponentStore(pathResolver, hierarchy.root());
+ store = new InputComponentStore(hierarchy.root());
}
return store;
}
*/
package org.sonar.scanner.cpd;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
-
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
-
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.batch.fs.internal.DefaultInputFile;
import org.sonar.api.batch.fs.internal.DefaultInputModule;
import org.sonar.api.batch.fs.internal.TestInputFileBuilder;
-import org.sonar.api.scan.filesystem.PathResolver;
import org.sonar.api.utils.log.LogTester;
import org.sonar.api.utils.log.LoggerLevel;
import org.sonar.core.util.CloseableIterator;
import org.sonar.scanner.report.ReportPublisher;
import org.sonar.scanner.scan.filesystem.InputComponentStore;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
public class CpdExecutorTest {
@Rule
public LogTester logTester = new LogTester();
index = new SonarCpdBlockIndex(publisher, settings);
DefaultInputModule inputModule = TestInputFileBuilder.newDefaultInputModule("foo", baseDir);
- componentStore = new InputComponentStore(new PathResolver(), inputModule);
+ componentStore = new InputComponentStore(inputModule);
executor = new CpdExecutor(settings, index, publisher, componentStore);
reader = new ScannerReportReader(outputDir);
import org.sonar.api.batch.postjob.issue.PostJobIssue;
import org.sonar.api.batch.rule.Severity;
import org.sonar.api.config.internal.MapSettings;
-import org.sonar.api.scan.filesystem.PathResolver;
import org.sonar.scanner.issue.IssueCache;
import org.sonar.scanner.issue.tracking.TrackedIssue;
import org.sonar.scanner.scan.filesystem.InputComponentStore;
public void setUp() throws IOException {
issueCache = mock(IssueCache.class);
DefaultInputModule rootModule = TestInputFileBuilder.newDefaultInputModule("foo", temp.newFolder());
- componentStore = new InputComponentStore(new PathResolver(), rootModule);
+ componentStore = new InputComponentStore(rootModule);
settings = new MapSettings();
analysisMode = mock(AnalysisMode.class);
context = new DefaultPostJobContext(settings.asConfig(), settings, issueCache, componentStore, analysisMode);
import org.sonar.api.batch.fs.internal.TestInputFileBuilder;
import org.sonar.api.batch.sensor.measure.internal.DefaultMeasure;
import org.sonar.api.measures.CoreMetrics;
-import org.sonar.api.scan.filesystem.PathResolver;
import org.sonar.core.util.CloseableIterator;
import org.sonar.scanner.protocol.output.ScannerReport.LineCoverage;
import org.sonar.scanner.protocol.output.ScannerReportReader;
String moduleKey = "foo";
inputFile = new TestInputFileBuilder(moduleKey, "src/Foo.php").setLines(5).build();
DefaultInputModule rootModule = TestInputFileBuilder.newDefaultInputModule(moduleKey, temp.newFolder());
- InputComponentStore componentCache = new InputComponentStore(new PathResolver(), rootModule);
+ InputComponentStore componentCache = new InputComponentStore(rootModule);
componentCache.put(inputFile);
measureCache = mock(MeasureCache.class);
import org.sonar.api.batch.fs.internal.TestInputFileBuilder;
import org.sonar.api.batch.sensor.measure.internal.DefaultMeasure;
import org.sonar.api.measures.CoreMetrics;
-import org.sonar.api.scan.filesystem.PathResolver;
import org.sonar.core.util.CloseableIterator;
import org.sonar.scanner.deprecated.test.TestPlanBuilder;
import org.sonar.scanner.protocol.output.ScannerReport;
String moduleKey = "foo";
inputModule = TestInputFileBuilder.newDefaultInputModule(moduleKey, temp.newFolder());
inputFile = new TestInputFileBuilder(moduleKey, "src/Foo.php").setPublish(true).build();
- InputComponentStore componentCache = new InputComponentStore(new PathResolver(), inputModule);
+ InputComponentStore componentCache = new InputComponentStore(inputModule);
componentCache.put(inputFile);
measureCache = mock(MeasureCache.class);
when(measureCache.byComponentKey(anyString())).thenReturn(Collections.<DefaultMeasure<?>>emptyList());
import org.sonar.api.batch.fs.internal.DefaultInputFile;
import org.sonar.api.batch.fs.internal.DefaultInputModule;
import org.sonar.api.batch.fs.internal.TestInputFileBuilder;
-import org.sonar.api.scan.filesystem.PathResolver;
import org.sonar.scanner.protocol.output.ScannerReportWriter;
import org.sonar.scanner.scan.filesystem.InputComponentStore;
.build();
DefaultInputModule rootModule = TestInputFileBuilder.newDefaultInputModule(moduleKey, baseDir);
- InputComponentStore componentStore = new InputComponentStore(new PathResolver(), rootModule);
+ InputComponentStore componentStore = new InputComponentStore(rootModule);
componentStore.put(inputFile);
publisher = new SourcePublisher(componentStore);
*/
package org.sonar.scanner.scan;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
-
import java.util.Arrays;
-
import org.junit.Test;
import org.sonar.api.batch.bootstrap.ProjectDefinition;
import org.sonar.api.batch.fs.InputModule;
import org.sonar.api.batch.fs.internal.DefaultInputModule;
-import org.sonar.api.scan.filesystem.PathResolver;
import org.sonar.scanner.scan.filesystem.InputComponentStore;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
public class ModuleIndexerTest {
private ModuleIndexer indexer;
private DefaultComponentTree tree;
private InputComponentStore componentStore;
public void createIndexer(DefaultInputModule rootModule) {
- componentStore = new InputComponentStore(new PathResolver(), rootModule);
+ componentStore = new InputComponentStore(rootModule);
tree = new DefaultComponentTree();
moduleHierarchy = mock(DefaultInputModuleHierarchy.class);
indexer = new ModuleIndexer(tree, componentStore, moduleHierarchy);
}
-
+
@Test
public void testIndex() {
ProjectDefinition rootDef = mock(ProjectDefinition.class);
ProjectDefinition def = mock(ProjectDefinition.class);
when(rootDef.getParent()).thenReturn(null);
when(def.getParent()).thenReturn(rootDef);
-
+
DefaultInputModule root = mock(DefaultInputModule.class);
DefaultInputModule mod1 = mock(DefaultInputModule.class);
DefaultInputModule mod2 = mock(DefaultInputModule.class);
when(mod1.key()).thenReturn("mod1");
when(mod2.key()).thenReturn("mod2");
when(mod3.key()).thenReturn("mod3");
-
+
when(root.getKeyWithBranch()).thenReturn("root");
when(mod1.getKeyWithBranch()).thenReturn("mod1");
when(mod2.getKeyWithBranch()).thenReturn("mod2");
import org.sonar.api.batch.fs.internal.DefaultInputFile;
import org.sonar.api.batch.fs.internal.DefaultInputModule;
import org.sonar.api.batch.fs.internal.TestInputFileBuilder;
-import org.sonar.api.scan.filesystem.PathResolver;
import static org.assertj.core.api.Assertions.assertThat;
DefaultInputModule rootModule = TestInputFileBuilder.newDefaultInputModule(rootDef);
DefaultInputModule subModule = TestInputFileBuilder.newDefaultInputModule(moduleDef);
- InputComponentStore cache = new InputComponentStore(new PathResolver(), rootModule);
+ InputComponentStore cache = new InputComponentStore(rootModule);
cache.put(subModule);
DefaultInputFile fooFile = new TestInputFileBuilder(rootModuleKey, "src/main/java/Foo.java")
static class InputComponentStoreTester extends InputComponentStore {
InputComponentStoreTester() throws IOException {
- super(new PathResolver(), TestInputFileBuilder.newDefaultInputModule("root", temp.newFolder()));
+ super(TestInputFileBuilder.newDefaultInputModule("root", temp.newFolder()));
}
InputFile addFile(String moduleKey, String relpath, String language) {
import org.sonar.api.batch.fs.InputModule;
import org.sonar.api.batch.fs.internal.DefaultInputModule;
import org.sonar.api.batch.fs.internal.TestInputFileBuilder;
-import org.sonar.api.scan.filesystem.PathResolver;
import org.sonar.scanner.sensor.SensorStrategy;
import static org.assertj.core.api.Assertions.assertThat;
@Before
public void setUp() throws IOException {
DefaultInputModule root = TestInputFileBuilder.newDefaultInputModule(moduleKey, temp.newFolder());
- componentStore = new InputComponentStore(new PathResolver(), root);
+ componentStore = new InputComponentStore(root);
}
@Test
import org.sonar.api.issue.Issue;
import org.sonar.api.platform.Server;
import org.sonar.api.rule.RuleKey;
-import org.sonar.api.scan.filesystem.PathResolver;
import org.sonar.scanner.issue.IssueCache;
import org.sonar.scanner.issue.tracking.TrackedIssue;
import org.sonar.scanner.scan.DefaultComponentTree;
DefaultComponentTree inputComponentTree = new DefaultComponentTree();
ProjectDefinition def = ProjectDefinition.create().setBaseDir(projectBaseDir).setWorkDir(temp.newFolder()).setKey("struts");
DefaultInputModule rootModule = new DefaultInputModule(def, 1);
- InputComponentStore inputComponentStore = new InputComponentStore(new PathResolver(), rootModule);
+ InputComponentStore inputComponentStore = new InputComponentStore(rootModule);
DefaultInputModule moduleA = new DefaultInputModule(ProjectDefinition.create().setKey("struts-core").setBaseDir(temp.newFolder()).setWorkDir(temp.newFolder()));
inputComponentTree.index(moduleA, rootModule);
projects / sonarqube.git / commitdiff