/*
* Copyright 2013 eXo Platform SAS
*
* 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 juzu.impl.metamodel;
import japa.parser.ast.body.ClassOrInterfaceDeclaration;
import japa.parser.ast.body.FieldDeclaration;
import juzu.impl.common.Path;
import juzu.impl.compiler.ElementHandle;
import juzu.impl.plugin.module.metamodel.ModuleMetaModel;
import juzu.impl.common.Tools;
import juzu.impl.plugin.template.metamodel.ElementMetaModel;
import juzu.impl.plugin.template.metamodel.TemplateMetaModel;
import juzu.impl.plugin.template.metamodel.TemplateMetaModelPlugin;
import juzu.test.AbstractTestCase;
import juzu.test.CompilerAssert;
import juzu.test.JavaFile;
import org.junit.Test;
import java.io.File;
import java.io.FileWriter;
import java.io.StringReader;
import java.util.Collection;
import java.util.List;
import java.util.regex.Matcher;
/** @author <a href="mailto:julien.viet@exoplatform.com">Julien Viet</a> */
public class TemplateMetaModelTestCase extends AbstractTestCase {
@Test
public void testTemplatePathMatching() {
assertNotMatch("a");
assertMatch("a.b", "", "a", "b");
assertNotMatch("/a.b");
assertMatch("a/b.c", "a/", "b", "c");
assertNotMatch("/a/b.c");
assertNotMatch("a/b");
}
private void assertMatch(String test, String expectedFolder, String expectedRawName, String expectedExtension) {
Matcher matcher = TemplateMetaModelPlugin.PATH_PATTERN.matcher(test);
assertTrue("Was expecting " + test + " to match", matcher.matches());
assertEquals(expectedFolder, matcher.group(1));
assertEquals(expectedRawName, matcher.group(2));
assertEquals(expectedExtension, matcher.group(3));
}
private void assertNotMatch(String test) {
Matcher matcher = TemplateMetaModelPlugin.PATH_PATTERN.matcher(test);
assertFalse("Was not expecting " + test + " to match", matcher.matches());
}
@Test
public void testRemoveTemplate() throws Exception {
CompilerAssert<File, File> helper = compiler("metamodel.template");
helper.assertCompile();
//
assertDelete(helper.getSourcePath().getPath("metamodel", "template", "templates", "index.gtmpl"));
//
helper.failCompile();
}
@Test
public void testRemoveAnnotation() throws Exception {
CompilerAssert<File, File> helper = compiler("metamodel.template");
helper.assertCompile();
//
JavaFile file = helper.assertJavaSource("metamodel.template.A");
ClassOrInterfaceDeclaration a = file.assertDeclaration();
FieldDeclaration decl = (FieldDeclaration)a.getMembers().get(0);
decl.getAnnotations().clear();
file.assertSave();
//
File ser = helper.getSourceOutput().getPath("juzu", "metamodel.ser");
MetaModelState unserialize = Tools.unserialize(MetaModelState.class, ser);
ModuleMetaModel mm = (ModuleMetaModel)unserialize.metaModel;
mm.getQueue().clear();
Tools.serialize(unserialize, ser);
//
helper.assertCompile();
//
unserialize = Tools.unserialize(MetaModelState.class, ser);
mm = (ModuleMetaModel)unserialize.metaModel;
List<MetaModelEvent> events = mm.getQueue().clear();
assertEquals(1, events.size());
assertEquals(MetaModelEvent.BEFORE_REMOVE, events.get(0).getType());
assertInstanceOf(TemplateMetaModel.class, events.get(0).getObject());
}
@Test
public void testReferences() throws Exception {
ElementHandle.Field templateField = ElementHandle.Field.create("metamodel.template.A", "template");
CompilerAssert<File, File> helper = compiler("metamodel.template");
File templates = helper.getSourcePath().getPath("metamodel", "template", "templates");
File index = new File(templates, "index.gtmpl");
helper.assertCompile();
//
File ser = helper.getSourceOutput().getPath("juzu", "metamodel.ser");
MetaModelState unserialize = Tools.unserialize(MetaModelState.class, ser);
ModuleMetaModel mm = (ModuleMetaModel)unserialize.metaModel;
List<MetaModelEvent> events = mm.getQueue().clear();
Tools.serialize(unserialize, ser);
//
assertEquals(2, events.size());
assertEquals(MetaModelEvent.AFTER_ADD, events.get(1).getType());
TemplateMetaModel indexTemplate = (TemplateMetaModel)events.get(1).getObject();
assertEquals(Path.parse("/metamodel/template/templates/index.gtmpl"), indexTemplate.getPath());
Collection<ElementMetaModel> indexRefs = indexTemplate.getElementReferences();
assertEquals(1, indexRefs.size());
assertEquals(templateField, indexRefs.iterator().next().getElement());
// Create an inclusion
File foo = new File(templates, "foo.gtmpl");
assertTrue(foo.createNewFile());
Tools.safeClose(Tools.copy(new StringReader("#{include path=foo.gtmpl}#{/include}"), new FileWriter(index)));
assertTrue(index.setLastModified(index.lastModified() + 1000));
// Compile
helper.assertCompile();
unserialize = Tools.unserialize(MetaModelState.class, ser);
mm = (ModuleMetaModel)unserialize.metaModel;
events = mm.getQueue().clear();
Tools.serialize(unserialize, ser);
//
assertEquals(1, events.size());
assertEquals(MetaModelEvent.AFTER_ADD, events.get(0).getType());
TemplateMetaModel fooTemplate = (TemplateMetaModel)events.get(0).getObject();
assertEquals(Path.parse("/metamodel/template/templates/foo.gtmpl"), fooTemplate.getPath());
Collection<ElementMetaModel> fooRefs = fooTemplate.getElementReferences();
assertEquals(1, fooRefs.size());
assertEquals(templateField, fooRefs.iterator().next().getElement());
// Create an neted inclusion
File bar = new File(templates, "bar.gtmpl");
assertTrue(bar.createNewFile());
Tools.safeClose(Tools.copy(new StringReader("#{include path=bar.gtmpl}#{/include}"), new FileWriter(foo)));
assertTrue(foo.setLastModified(index.lastModified() + 1000));
// Compile
helper.assertCompile();
unserialize = Tools.unserialize(MetaModelState.class, ser);
mm = (ModuleMetaModel)unserialize.metaModel;
events = mm.getQueue().clear();
//
assertEquals(1, events.size());
assertEquals(MetaModelEvent.AFTER_ADD, events.get(0).getType());
TemplateMetaModel barTemplate = (TemplateMetaModel)events.get(0).getObject();
assertEquals(Path.parse("/metamodel/template/templates/bar.gtmpl"), barTemplate.getPath());
Collection<ElementMetaModel> barRefs = fooTemplate.getElementReferences();
assertEquals(1, barRefs.size());
assertEquals(templateField, barRefs.iterator().next().getElement());
}
}