com.thoughtworks.gauge.registry.StepRegistry Maven / Gradle / Ivy
/*----------------------------------------------------------------
* Copyright (c) ThoughtWorks, Inc.
* Licensed under the Apache License, Version 2.0
* See LICENSE.txt in the project root for license information.
*----------------------------------------------------------------*/
package com.thoughtworks.gauge.registry;
import com.thoughtworks.gauge.Logger;
import com.thoughtworks.gauge.StepRegistryEntry;
import com.thoughtworks.gauge.StepValue;
import gauge.messages.Messages;
import gauge.messages.Spec;
import java.io.File;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CopyOnWriteArrayList;
import static java.util.stream.Collectors.toCollection;
import static java.util.stream.Collectors.toList;
public class StepRegistry {
private ConcurrentHashMap> registry;
public StepRegistry() {
registry = new ConcurrentHashMap<>();
}
public void addStepImplementation(StepValue stepValue, Method method, boolean isExternal) {
String stepText = stepValue.getStepText();
registry.putIfAbsent(stepText, new CopyOnWriteArrayList<>());
registry.get(stepText).add(new StepRegistryEntry(stepValue, method, isExternal));
}
public void clear() {
this.registry = new ConcurrentHashMap<>();
}
public List keys() {
return Collections.list(this.registry.keys());
};
public boolean contains(String stepTemplateText) {
return registry.containsKey(stepTemplateText);
}
public StepRegistryEntry get(String stepTemplateText) {
return getFirstEntry(stepTemplateText);
}
public StepRegistryEntry getForCurrentProject(String stepTemplateText, Method method) {
return registry.get(stepTemplateText).stream()
.filter(e -> {
String reflectedMethodName = method.getDeclaringClass().getName() + "." + method.getName();
Logger.debug("Comparing '" + e.getFullyQualifiedName() + "' and '"
+ reflectedMethodName + "'");
return !e.getIsExternal() && e.getFullyQualifiedName().equals(reflectedMethodName);
})
.findFirst().orElse(null);
}
private StepRegistryEntry getFirstEntry(String stepTemplateText) {
return registry.getOrDefault(stepTemplateText, new CopyOnWriteArrayList<>()).stream()
.findFirst()
.orElse(new StepRegistryEntry());
}
public List getAllStepAnnotationTexts() {
return registry.values().stream().flatMap(Collection::stream)
.map(entry -> entry.getStepValue().getStepAnnotationText())
.collect(toList());
}
String getStepAnnotationFor(String stepTemplateText) {
return registry.values().stream().flatMap(Collection::stream).map(StepRegistryEntry::getStepValue)
.filter(stepValue -> stepValue.getStepText().equals(stepTemplateText))
.map(StepValue::getStepAnnotationText).findFirst().orElse("");
}
public void remove(String stepTemplateText) {
registry.remove(stepTemplateText);
}
List getAllEntries(String stepText) {
return registry.get(stepText);
}
public void removeSteps(String fileName) {
ConcurrentHashMap> newRegistry = new ConcurrentHashMap<>();
for (String key : registry.keySet()) {
CopyOnWriteArrayList newEntryList = registry.get(key).stream()
.filter(entry -> entry.getFileName() != null && !entry.getFileName().equals(fileName)).collect(toCollection(CopyOnWriteArrayList::new));
if (newEntryList.size() > 0) {
newRegistry.put(key, newEntryList);
}
}
registry = newRegistry;
}
public void addStep(StepValue stepValue, StepRegistryEntry entry) {
String stepText = stepValue.getStepText();
registry.putIfAbsent(stepText, new CopyOnWriteArrayList<>());
registry.get(stepText).add(entry);
}
public boolean hasMultipleImplementations(String stepToValidate) {
return getAllEntries(stepToValidate).size() > 1;
}
public List getStepPositions(String filePath) {
List stepPositionsList = new ArrayList<>();
for (Map.Entry> entryList : registry.entrySet()) {
for (StepRegistryEntry entry : entryList.getValue()) {
if (entry.getFileName().equals(filePath)) {
Messages.StepPositionsResponse.StepPosition stepPosition = Messages.StepPositionsResponse.StepPosition.newBuilder()
.setStepValue(entryList.getKey())
.setSpan(Spec.Span.newBuilder()
.setStart(entry.getSpan().begin.line)
.setStartChar(entry.getSpan().begin.column)
.setEnd(entry.getSpan().end.line)
.setEndChar(entry.getSpan().end.column).build())
.build();
stepPositionsList.add(stepPosition);
}
}
}
return stepPositionsList;
}
public boolean isFileCached(String fileName) {
for (String key : registry.keySet()) {
if (registry.get(key).stream().anyMatch(entry -> entry.getFileName().equals(fileName))) {
return true;
}
}
return false;
}
public String getFileName(String oldStepText) {
Method method = get(oldStepText).getMethodInfo();
if (method == null) {
return "";
}
return method.getDeclaringClass().getCanonicalName().replace(".", File.separator) + ".java";
}
}