buildSrc/src/main/java/cc/squirreljme/plugin/ErrorListManager.java

   1 // -*- Mode: Java; indent-tabs-mode: t; tab-width: 4 -*-
   2 // ---------------------------------------------------------------------------
   3 // SquirrelJME
   4 //     Copyright (C) Stephanie Gawroriski <xer@multiphasicapps.net>
   5 // ---------------------------------------------------------------------------
   6 // SquirrelJME is under the GNU General Public License v3+, or later.
   7 // See license.mkd for licensing and copyright information.
   8 // ---------------------------------------------------------------------------
   9
  10 package cc.squirreljme.plugin;
  11
  12 import cc.squirreljme.plugin.util.CommentReader;
  13 import cc.squirreljme.plugin.util.ErrorListTokenizer;
  14 import java.io.File;
  15 import java.io.IOException;
  16 import java.io.InputStream;
  17 import java.io.PrintStream;
  18 import java.nio.file.Files;
  19 import java.nio.file.StandardOpenOption;
  20 import java.util.Map;
  21 import java.util.TreeMap;
  22 import org.gradle.api.Project;
  23 import org.gradle.api.file.FileTree;
  24 import org.gradle.api.plugins.JavaPluginConvention;
  25 import org.gradle.api.tasks.SourceSet;
  26
  27 /**
  28  * This is a mapping of individual error codes for a project.
  29  *
  30  * @since 2020/02/22
  31  */
  32 public final class ErrorListManager
  33 {
  34         /** The project to manage the list for. */
  35         protected final Project project;
  36
  37         /** The listed errors. */
  38         private final Map<Integer, SourceError> _errors =
  39                 new TreeMap<>();
  40
  41         /** The error code for this project. */
  42         private String _projectErrorCode;
  43
  44         /**
  45          * Initializes the error code manager.
  46          *
  47          * @param __project The project to manage.
  48          * @throws NullPointerException On null arguments.
  49          * @since 2020/02/22
  50          */
  51         public ErrorListManager(Project __project)
  52                 throws NullPointerException
  53         {
  54                 if (__project == null)
  55                         throw new NullPointerException("No project.");
  56
  57                 this.project = __project;
  58         }
  59
  60         /**
  61          * Returns the next available error.
  62          *
  63          * @return The next available error.
  64          * @since 2020/02/22
  65          */
  66         public final String next()
  67         {
  68                 this.__init();
  69
  70                 return this._projectErrorCode +
  71                         SourceError.indexToString(this.nextIndex());
  72         }
  73
  74         /**
  75          * Returns the next available error.
  76          *
  77          * @return The next available error.
  78          * @since 2020/02/22
  79          */
  80         public final int nextIndex()
  81         {
  82                 this.__init();
  83
  84                 Map<Integer, SourceError> errors = this._errors;
  85                 synchronized (this)
  86                 {
  87                         for (int i = 1; i <= SourceError._MAX_ERROR_CODE; i++)
  88                                 if (!errors.containsKey(i))
  89                                         return i;
  90
  91                         throw new IllegalArgumentException("Ran out of error indexes.");
  92                 }
  93         }
  94
  95         /**
  96          * Prints the errors to the given stream.
  97          *
  98          * @param __out The stream to write to.
  99          * @throws NullPointerException On null arguments.
 100          * @since 2020/02/22
 101          */
 102         public final void print(PrintStream __out)
 103                 throws NullPointerException
 104         {
 105                 if (__out == null)
 106                         throw new NullPointerException("No stream specified.");
 107
 108                 this.__init();
 109
 110                 synchronized (this)
 111                 {
 112                         for (SourceError e : this._errors.values())
 113                                 __out.println(e);
 114                 }
 115         }
 116
 117         /**
 118          * Initializes the code map.
 119          *
 120          * @since 2020/02/22
 121          */
 122         private void __init()
 123         {
 124                 Project project = this.project;
 125                 Map<Integer, SourceError> errors = this._errors;
 126
 127                 synchronized (this)
 128                 {
 129                         // Already loaded?
 130                         if (this._projectErrorCode != null)
 131                                 return;
 132
 133                         // This must exist
 134                         SquirrelJMEPluginConfiguration config = project.getExtensions()
 135                                 .<SquirrelJMEPluginConfiguration>getByType(
 136                                         SquirrelJMEPluginConfiguration.class);
 137
 138                         // Fail if this is missing
 139                         String projectErrorCode = config.javaDocErrorCode;
 140                         if (projectErrorCode == null)
 141                                 throw new IllegalStateException(String.format(
 142                                         "Project %s has no error code.", project.getName()));
 143
 144                         // Used as a flag and to indicate the group for this
 145                         this._projectErrorCode = projectErrorCode;
 146
 147                         // Temporary buffer for data reading
 148                         StringBuilder buffer = new StringBuilder();
 149
 150                         // Get source code
 151                         FileTree sources = project.getConvention()
 152                                 .getPlugin(JavaPluginConvention.class).getSourceSets()
 153                                 .getByName(SourceSet.MAIN_SOURCE_SET_NAME).getAllJava()
 154                                 .getAsFileTree();
 155
 156                         // Parse source code
 157                         for (File source : sources)
 158                                 try (InputStream in = Files.newInputStream(source.toPath(),
 159                                         StandardOpenOption.READ);
 160                                         ErrorListTokenizer tokenizer = new ErrorListTokenizer(
 161                                                 source.toPath().getFileName(),
 162                                                 new CommentReader(in)))
 163                                 {
 164                                         // Keep reading in errors
 165                                         for (;;)
 166                                         {
 167                                                 // Read the next error
 168                                                 SourceError error = tokenizer.next();
 169                                                 if (error == null)
 170                                                         break;
 171
 172                                                 // Store error in the map
 173                                                 SourceError old = errors.put(error.index, error);
 174
 175                                                 // Check duplicate
 176                                                 if (old != null)
 177                                                         System.err.printf("Duplicate error %s and %s.%n",
 178                                                                 error, old);
 179
 180                                                 // Wrong project
 181                                                 if (!error.projectCode.equals(projectErrorCode))
 182                                                         System.err.printf("Error has wrong project: %s," +
 183                                                                 "should be: %s%n", error, projectErrorCode);
 184                                         }
 185                                 }
 186                                 catch (IOException e)
 187                                 {
 188                                         throw new RuntimeException("Could not decode file.", e);
 189                                 }
 190                 }
 191         }
 192
 193 }