Fix XSD validation for includes with subdirectories in global schemas

Author: svacas

src/main/java/org/raml/model/Raml.java

@@ -26,6 +26,7 @@
 import org.raml.parser.annotation.Mapping;
 import org.raml.parser.annotation.Scalar;
 import org.raml.parser.annotation.Sequence;
+import org.raml.parser.builder.GlobalSchemaSequenceTupleBuilder;
 import org.raml.parser.resolver.ResourceHandler;
 import org.raml.parser.rule.SecurityReferenceSequenceRule;
 
@@ -53,7 +54,7 @@ public class Raml implements Serializable
     @Scalar()
     private String mediaType;
 
-    @Sequence(rule = org.raml.parser.rule.GlobalSchemasRule.class)
+    @Sequence(rule = org.raml.parser.rule.GlobalSchemasRule.class, builder = GlobalSchemaSequenceTupleBuilder.class)
     private List<Map<String, String>> schemas = new ArrayList<Map<String, String>>();
 
     private transient Map<String, Object> compiledSchemas;

src/main/java/org/raml/parser/builder/GlobalSchemaMapTupleBuilder.java

@@ -0,0 +1,38 @@
+/*
+ * Copyright 2013 (c) MuleSoft, Inc.
+ *
+ * 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.raml.parser.builder;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class GlobalSchemaMapTupleBuilder extends MapTupleBuilder
+{
+
+    public static final Class<String> VALUE_CLASS = String.class;
+
+    public GlobalSchemaMapTupleBuilder()
+    {
+        super(VALUE_CLASS);
+    }
+
+    protected void addBuilders()
+    {
+        TupleBuilder tupleBuilder = new GlobalSchemaScalarTupleBuilder();
+        Map<String, TupleBuilder<?,?>> builderMap = new HashMap<String, TupleBuilder<?, ?>>();
+        builderMap.put(null, tupleBuilder);
+        this.setChildrenTupleBuilders(builderMap);
+    }
+}

src/main/java/org/raml/parser/builder/GlobalSchemaScalarTupleBuilder.java

@@ -0,0 +1,46 @@
+/*
+ * Copyright 2013 (c) MuleSoft, Inc.
+ *
+ * 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.raml.parser.builder;
+
+import org.raml.parser.utils.ReflectionUtils;
+import org.raml.parser.visitor.SchemaCompiler;
+import org.yaml.snakeyaml.nodes.ScalarNode;
+
+public class GlobalSchemaScalarTupleBuilder extends ScalarTupleBuilder
+{
+
+    private String key;
+
+    public GlobalSchemaScalarTupleBuilder()
+    {
+        super(null, String.class);
+    }
+
+    @Override
+    public Object buildValue(Object parent, ScalarNode node)
+    {
+        String value = SchemaCompiler.encodeIncludePath(node);
+        ReflectionUtils.setProperty(parent, key, value);
+        return parent;
+    }
+
+    @Override
+    public void buildKey(Object parent, ScalarNode tuple)
+    {
+        super.buildKey(parent, tuple);
+        this.key = tuple.getValue();
+    }
+}

src/main/java/org/raml/parser/builder/GlobalSchemaSequenceTupleBuilder.java

@@ -0,0 +1,33 @@
+/*
+ * Copyright 2013 (c) MuleSoft, Inc.
+ *
+ * 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.raml.parser.builder;
+
+import java.util.HashMap;
+
+public class GlobalSchemaSequenceTupleBuilder extends SequenceTupleBuilder
+{
+
+    public GlobalSchemaSequenceTupleBuilder()
+    {
+        super("schemas", new HashMap<String, String>(){}.getClass().getGenericSuperclass());
+    }
+
+    @Override
+    public NodeBuilder getItemBuilder()
+    {
+        return new GlobalSchemaMapTupleBuilder();
+    }
+}

src/main/java/org/raml/parser/builder/MapTupleBuilder.java

@@ -44,7 +44,7 @@ public MapTupleBuilder(String fieldName, Class<?> valueClass)
         this.valueClass = valueClass;
     }
 
-    private void addBuilders()
+    protected void addBuilders()
     {
         TupleBuilder tupleBuilder;
         if (ReflectionUtils.isPojo(getValueClass()))

src/main/java/org/raml/parser/visitor/RamlDocumentBuilder.java

@@ -18,6 +18,9 @@
 import static org.raml.parser.rule.BaseUriRule.URI_PATTERN;
 
 import java.lang.reflect.Field;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
 import java.util.Stack;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
@@ -152,7 +155,13 @@ private void compileGlobalSchemas()
     {
         SchemaCompiler compiler = SchemaCompiler.getInstance();
         Raml raml = getDocumentObject();
-        raml.setCompiledSchemas(compiler.compile(raml.getConsolidatedSchemas()));
+        Map<String, Object> compiledSchemas = new HashMap<String, Object>();
+        List<Map<String, String>> schemas = raml.getSchemas();
+        for (Map<String, String> schemaMap : schemas)
+        {
+            compiledSchemas.putAll(compiler.compile(schemaMap));
+        }
+        raml.setCompiledSchemas(compiledSchemas);
     }
 
     private void populateDefaultUriParameters(Resource resource)

src/main/java/org/raml/parser/visitor/SchemaCompiler.java

@@ -20,6 +20,7 @@
 import java.util.Map;
 
 import javax.xml.XMLConstants;
+import javax.xml.bind.DatatypeConverter;
 import javax.xml.transform.stream.StreamSource;
 import javax.xml.validation.Schema;
 import javax.xml.validation.SchemaFactory;
@@ -28,11 +29,14 @@
 import org.raml.parser.XsdResourceResolver;
 import org.raml.parser.loader.ResourceLoader;
 import org.raml.parser.tagresolver.ContextPath;
+import org.raml.parser.tagresolver.IncludeResolver;
+import org.yaml.snakeyaml.nodes.ScalarNode;
 
-public class SchemaCompiler
+public final class SchemaCompiler
 {
 
-    private final static SchemaCompiler instance = new SchemaCompiler();
+    private static final String SEPARATOR = "-|_";
+    private static final SchemaCompiler instance = new SchemaCompiler();
     private ContextPath contextPath;
     private ResourceLoader resourceLoader;
 
@@ -55,28 +59,35 @@ public void init(ContextPath contextPath, ResourceLoader resourceLoader)
         this.resourceLoader = resourceLoader;
     }
 
-    public Map<String, Object> compile(Map<String, String> schemas)
+    public Map<String, Object> compile(Map<String, String> encodedSchemas)
     {
         Map<String, Object> compiledSchemas = new HashMap<String, Object>();
-        for (Map.Entry<String, String> schema : schemas.entrySet())
+        for (Map.Entry<String, String> encodedSchema : encodedSchemas.entrySet())
         {
-            Schema compiledSchema = compile(schema.getValue());
+            String[] pathAndSchema = decodeIncludePath(encodedSchema.getValue());
+            Schema compiledSchema = compile(pathAndSchema[1], pathAndSchema[0]);
             if (compiledSchema != null)
             {
-                compiledSchemas.put(schema.getKey(), compiledSchema);
+                compiledSchemas.put(encodedSchema.getKey(), compiledSchema);
             }
+            encodedSchema.setValue(pathAndSchema[1]);
         }
         return compiledSchemas;
     }
 
-    public Schema compile(String schema)
+    public Schema compile(String schema, String path)
     {
         Schema compiledSchema = null;
         String trimmedSchema = StringUtils.trimToEmpty(schema);
         if (trimmedSchema.startsWith("<") && trimmedSchema.endsWith(">"))
         {
             SchemaFactory factory = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
-            factory.setResourceResolver(new XsdResourceResolver(contextPath, resourceLoader));
+            ContextPath actualContextPath = contextPath;
+            if (path != null)
+            {
+                actualContextPath = new ContextPath(new IncludeInfo(path));
+            }
+            factory.setResourceResolver(new XsdResourceResolver(actualContextPath, resourceLoader));
             try
             {
                 compiledSchema = factory.newSchema(new StreamSource(new StringReader(trimmedSchema)));
@@ -89,4 +100,35 @@ public Schema compile(String schema)
         }
         return compiledSchema;
     }
+
+    public Schema compile(String schema)
+    {
+        return compile(schema, null);
+    }
+
+    public static String encodeIncludePath(ScalarNode node)
+    {
+        String schema = node.getValue();
+        String includePath = "";
+        if (node instanceof IncludeResolver.IncludeScalarNode)
+        {
+            includePath = ((IncludeResolver.IncludeScalarNode) node).getIncludeName();
+        }
+        String includeEncoded = DatatypeConverter.printBase64Binary(includePath.getBytes());
+
+        return includeEncoded + SEPARATOR + schema;
+    }
+
+    public static String[] decodeIncludePath(String encodedSchema)
+    {
+        int idx = encodedSchema.indexOf(SEPARATOR);
+        if (idx == -1)
+        {
+            throw new IllegalArgumentException("Invalid include encoded schema.");
+        }
+        String base64Path = encodedSchema.substring(0, idx);
+        String includePath = new String(DatatypeConverter.parseBase64Binary(base64Path));
+        String schema = encodedSchema.substring(idx + SEPARATOR.length(), encodedSchema.length());
+        return new String[] {includePath, schema};
+    }
 }

src/test/java/org/raml/parser/builder/SchemaBuilderTestCase.java

@@ -36,7 +36,7 @@ public void xsdWithInclude()
         MimeType mimeType = raml.getResources().get("/name").getAction(GET).getResponses().get("200").getBody().get("application/xml");
         assertThat(mimeType.getCompiledSchema(), is(Schema.class));
         assertThat(mimeType.getSchema(), is(String.class));
-        assertThat(mimeType.getSchema(), containsString("include schemaLocation=\"refs/xsd-include.xsd\""));
+        assertThat(mimeType.getSchema(), containsString("include schemaLocation=\"xsd-include.xsd\""));
     }
 
     @Test

src/test/resources/org/raml/schema/refs/xsd-includer-nested.xsd

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xs:schema targetNamespace="http://www.example.org/simple"
+        elementFormDefault="qualified" xmlns:xs="http://www.w3.org/2001/XMLSchema"
+        xmlns="http://www.example.org/simple">
+    <xs:include schemaLocation="xsd-include.xsd"></xs:include>
+    <xs:element name="message" type="Message"></xs:element>
+</xs:schema>

src/test/resources/org/raml/schema/xsd-global-includer.raml

@@ -2,7 +2,7 @@
 ---
 title: Sample API
 schemas:
-    - name-schema: !include xsd-includer.xsd
+    - name-schema: !include refs/xsd-includer-nested.xsd
 /name:
     get:
         responses: