@Override public synchronized void init(ProcessingEnvironment env) { this.stereotypesProviders = getStereotypesProviders(env); this.typeHelper = new TypeHelper(env); this.metadataStore = new MetadataStore(env); this.metadataCollector = new MetadataCollector(env, this.metadataStore.readMetadata()); }
private boolean shouldBeMerged(ItemMetadata itemMetadata) { String sourceType = itemMetadata.getType(); return (sourceType != null && !deletedInCurrentBuild(sourceType) && !processedInCurrentBuild(sourceType)); }
private void collectStereotypesOnAnnotations(Set<Element> seen, Set<String> stereotypes, Element element) { for (AnnotationMirror annotation : this.typeHelper.getAllAnnotationMirrors(element)) { Element next = collectStereotypes(seen, stereotypes, element, annotation); if (next != null) { collectStereotypesOnAnnotations(seen, stereotypes, next); } } }
@Test public void readWrite() throws IOException { CandidateComponentsMetadata metadata = new CandidateComponentsMetadata(); metadata.add(createItem("com.foo", "first", "second")); metadata.add(createItem("com.bar", "first")); ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); PropertiesMarshaller.write(metadata, outputStream); CandidateComponentsMetadata readMetadata = PropertiesMarshaller.read( new ByteArrayInputStream(outputStream.toByteArray())); assertThat(readMetadata, hasComponent("com.foo", "first", "second")); assertThat(readMetadata, hasComponent("com.bar", "first")); assertThat(readMetadata.getItems(), hasSize(2)); }
public CandidateComponentsMetadata getMetadata() { CandidateComponentsMetadata metadata = new CandidateComponentsMetadata(); for (ItemMetadata item : this.metadataItems) { metadata.add(item); } if (this.previousMetadata != null) { List<ItemMetadata> items = this.previousMetadata.getItems(); for (ItemMetadata item : items) { if (shouldBeMerged(item)) { metadata.add(item); } } } return metadata; }
private void addMetadataFor(Element element) { Set<String> stereotypes = new LinkedHashSet<>(); this.stereotypesProviders.forEach(p -> stereotypes.addAll(p.getStereotypes(element))); if (!stereotypes.isEmpty()) { this.metadataCollector.add(new ItemMetadata(this.typeHelper.getType(element), stereotypes)); } }
private List<StereotypesProvider> getStereotypesProviders(ProcessingEnvironment env) { List<StereotypesProvider> result = new ArrayList<>(); TypeHelper typeHelper = new TypeHelper(env); result.add(new IndexedStereotypesProvider(typeHelper)); result.add(new StandardStereotypesProvider(typeHelper)); result.add(new PackageInfoStereotypesProvider()); return result; }
public void writeMetadata(CandidateComponentsMetadata metadata) throws IOException { if (!metadata.getItems().isEmpty()) { try (OutputStream outputStream = createMetadataResource().openOutputStream()) { PropertiesMarshaller.write(metadata, outputStream); } } }
private void writeMetaData() { CandidateComponentsMetadata metadata = this.metadataCollector.getMetadata(); if (!metadata.getItems().isEmpty()) { try { this.metadataStore.writeMetadata(metadata); } catch (IOException ex) { throw new IllegalStateException("Failed to write metadata", ex); } } }
private Element collectStereotypes(Set<Element> seen, Set<String> stereotypes, Element element, AnnotationMirror annotation) { if (isIndexedAnnotation(annotation)) { stereotypes.add(this.typeHelper.getType(element)); } return getCandidateAnnotationElement(seen, annotation); }
private void testSingleComponent(Class<?> target, Class<?>... stereotypes) { CandidateComponentsMetadata metadata = compile(target); assertThat(metadata, hasComponent(target, stereotypes)); assertThat(metadata.getItems(), hasSize(1)); }
public CandidateComponentsMetadata readMetadata() { try { return readMetadata(getMetadataResource().openInputStream()); } catch (IOException ex) { // Failed to read metadata -> ignore. return null; } }
@Override public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) { this.metadataCollector.processing(roundEnv); roundEnv.getRootElements().forEach(this::processElement); if (roundEnv.processingOver()) { writeMetaData(); } return false; }
private CandidateComponentsMetadata compile(String... types) { CandidateComponentsIndexer processor = new CandidateComponentsIndexer(); this.compiler.getTask(types).call(processor); return readGeneratedMetadata(this.compiler.getOutputLocation()); }
/** * Create a new {@code MetadataProcessor} instance. * @param processingEnvironment the processing environment of the build * @param previousMetadata any previous metadata or {@code null} */ public MetadataCollector(ProcessingEnvironment processingEnvironment, CandidateComponentsMetadata previousMetadata) { this.processingEnvironment = processingEnvironment; this.previousMetadata = previousMetadata; this.typeHelper = new TypeHelper(processingEnvironment); }
@Test public void packageInfo() { CandidateComponentsMetadata metadata = compile( "org/springframework/context/index/sample/jpa/package-info"); assertThat(metadata, hasComponent( "org.springframework.context.index.sample.jpa", "package-info")); }
public static ItemMetadataMatcher hasComponent(String type, String... stereotypes) { return new ItemMetadataMatcher(type, stereotypes); }
private void testComponent(Class<?>... classes) { CandidateComponentsMetadata metadata = compile(classes); for (Class<?> c : classes) { assertThat(metadata, hasComponent(c, Component.class)); } assertThat(metadata.getItems(), hasSize(classes.length)); }
private CandidateComponentsMetadata compile(Class<?>... types) { CandidateComponentsIndexer processor = new CandidateComponentsIndexer(); this.compiler.getTask(types).call(processor); return readGeneratedMetadata(this.compiler.getOutputLocation()); }