Check that explicitly defined context is present in the file name

Author: leventov

core/src/main/java/io/timeandspace/jpsg/Context.java

@@ -21,21 +21,25 @@
 
 public final class Context implements Iterable<Map.Entry<String, Option>> {
 
+    static boolean stringIncludesOption(String s, Option option) {
+        String replacedString = option.intermediateReplace(s, "dummy");
+        return !s.equals(replacedString);
+    }
+
     static Builder builder() {
         return new Builder();
     }
 
     static class Builder {
-        private final LinkedHashMap<String, Option> options = new LinkedHashMap<String, Option>();
+        private final LinkedHashMap<String, Option> options = new LinkedHashMap<>();
 
         Builder put(String dim, Option option) {
             options.put(dim, option);
             return this;
         }
 
         Context makeContext() {
-            // noinspection unchecked
-            return new Context(new LinkedHashMap<String, Option>(options));
+            return new Context(new LinkedHashMap<>(options));
         }
     }
 
@@ -52,8 +56,7 @@ public Iterator<Map.Entry<String, Option>> iterator() {
     }
 
     public Context join(Context additionalContext) {
-        // noinspection unchecked
-        LinkedHashMap<String, Option> newOptions = new LinkedHashMap<String, Option>(options);
+        LinkedHashMap<String, Option> newOptions = new LinkedHashMap<>(options);
         for ( Map.Entry<String, Option> e : additionalContext.options.entrySet() ) {
             newOptions.put(e.getKey(), e.getValue());
         }

core/src/main/java/io/timeandspace/jpsg/Generator.kt

@@ -306,12 +306,11 @@ class Generator {
             defaultContext = defaultContext!!.join(contexts[0])
         }
 
-        excludedTypes = never
-                .flatMap({ options -> Dimensions.Parser.parseOptions(options) }).toList()
+        excludedTypes = never.flatMap { options -> parseOptions(options) }.toList()
 
-        permissiveConditions = included.map({ dimensionsParser!!.parse(it) }).toList()
+        permissiveConditions = included.map { dimensionsParser!!.parse(it) }.toList()
 
-        prohibitingConditions = excluded.map({ dimensionsParser!!.parse(it) }).toList()
+        prohibitingConditions = excluded.map { dimensionsParser!!.parse(it) }.toList()
 
         initProcessors()
     }
@@ -333,16 +332,16 @@ class Generator {
         setCurrentSourceFile(sourceFile)
         log.info("Processing file: {}", sourceFile)
         val sourceFileName = sourceFile.name
-        var targetDims = dimensionsParser!!.parseClassName(sourceFileName)
+        var targetDims: Dimensions = dimensionsParser!!.parseClassName(sourceFileName)
         var rawContent = sourceFile.readText()
         val fileDimsM = CONTEXT_START_P.matcher(rawContent)
         if (fileDimsM.find() && fileDimsM.start() == 0) {
-            targetDims = dimensionsParser!!.parseForContext(
-                    getBlockGroup(fileDimsM.group(), CONTEXT_START_BLOCK_P, "dimensions"))
-            rawContent = rawContent.substring(fileDimsM.end()).trim({ it <= ' ' }) + "\n"
+            val explicitContext = fileDimsM.group()
+            targetDims = parseAndCheckExplicitContext(explicitContext, sourceFile)
+            rawContent = rawContent.substring(fileDimsM.end()).trim { it <= ' ' } + "\n"
         }
         log.info("Target dimensions: {}", targetDims)
-        val targetContexts = targetDims.generateContexts()
+        val targetContexts: List<Context> = targetDims.generateContexts()
         val mainContext = defaultContext!!.join(targetContexts[0])
         val fileCondM = COND_START_P.matcher(rawContent)
         var fileCond: Condition? = null
@@ -351,7 +350,7 @@ class Generator {
                     getBlockGroup(fileCondM.group(), COND_START_BLOCK_P, "condition"),
                     dimensionsParser!!, mainContext,
                     rawContent, fileCondM.start())
-            rawContent = rawContent.substring(fileCondM.end()).trim({ it <= ' ' }) + "\n"
+            rawContent = rawContent.substring(fileCondM.end()).trim { it <= ' ' } + "\n"
         }
         val content = rawContent
 
@@ -404,6 +403,21 @@ class Generator {
         ForkJoinTasks.invokeAll(contextGenerationTasks)
     }
 
+    private fun parseAndCheckExplicitContext(explicitContext: String, sourceFile: File):
+            Dimensions {
+        val targetDims: Dimensions = dimensionsParser!!.parseForContext(
+                getBlockGroup(explicitContext, CONTEXT_START_BLOCK_P, "dimensions"))
+        val mainExplicitContext: Context = targetDims.generateContexts()[0]
+        for ((dim, option) in mainExplicitContext) {
+            if (!Context.stringIncludesOption(sourceFile.name, option)) {
+                throw RuntimeException(
+                        "Dimension $dim with options ${targetDims.dimensions[dim]} specified " +
+                                "explicitly in $sourceFile is not found in the file name")
+            }
+        }
+        return targetDims
+    }
+
     @Throws(IOException::class)
     internal fun writeFile(file: File, content: String) {
         file.writeText(content)
@@ -420,7 +434,7 @@ class Generator {
         }
         if (!checkPermissive(target))
             return false
-        if (!prohibitingConditions!!.isEmpty()) {
+        if (prohibitingConditions!!.isNotEmpty()) {
             for (prohibitingCondition in prohibitingConditions!!) {
                 if (prohibitingCondition.checkAsCondition(target))
                     return false
@@ -430,7 +444,7 @@ class Generator {
     }
 
     private fun checkPermissive(target: Context): Boolean {
-        if (!permissiveConditions!!.isEmpty()) {
+        if (permissiveConditions!!.isNotEmpty()) {
             for (permissiveCondition in permissiveConditions!!) {
                 if (permissiveCondition.checkAsCondition(target))
                     return true

core/src/main/java/io/timeandspace/jpsg/MalformedTemplateException.kt

@@ -31,14 +31,14 @@ class MalformedTemplateException private constructor(message: String) : RuntimeE
         }
 
         internal fun lines(s: String): List<String> {
-            val ls = s.split("\\n".toRegex()).dropLastWhile({ it.isEmpty() }).toTypedArray()
-            return ls.map({ l -> l + '\n' }).toList()
+            val ls = s.split("\\n".toRegex()).dropLastWhile { it.isEmpty() }.toTypedArray()
+            return ls.map { l -> l + '\n' }.toList()
         }
 
         private fun makeMessageNear(input: CharSequence, pos: Int, message: String): String {
             val messageNear = StringBuilder()
 
-            messageNear.append("Source file: " + Generator.currentSourceFile() + "\n")
+            messageNear.append("Source file: ${Generator.currentSourceFile()}\n")
             messageNear.append("$message:\n")
 
             val s = input.toString()
@@ -54,11 +54,11 @@ class MalformedTemplateException private constructor(message: String) : RuntimeE
                 charCount += line.length
             }
             val firstLine = max(targetLine - 2, 0)
-            lines.subList(firstLine, targetLine + 1).forEach({ messageNear.append(it) })
+            lines.subList(firstLine, targetLine + 1).forEach { messageNear.append(it) }
             val pointer = String(CharArray(pos - charCount)).replace('\u0000', ' ') + "^\n"
             messageNear.append(pointer)
             val lastLine = min(targetLine + 3, lines.size)
-            lines.subList(targetLine + 1, lastLine).forEach({ messageNear.append(it) })
+            lines.subList(targetLine + 1, lastLine).forEach { messageNear.append(it) }
             return messageNear.toString()
         }
     }