Added nameas filter to provide direct access to naming methods.

Author: Bob Garner

docs/etl/ETL.md

@@ -130,6 +130,7 @@ Here is the full list of filters:
 | [`name`](#filter_detail_name) | This simply calls `getName()` on the input. It is more of a convenient way to get the name by using a filter. |
 | [`path`](#filter_detail_path) | This will convert a string or namespace object into a string where by a '/' character is used as a delimiter instead of a '.'. This is useful when you need to convert a namespace into a filepath. |
 | [`plural`](#filter_detail_plural) | This will attempt to pluralize the last word of the input string. If it can't determine the pluralization it may just return the same string. |
+| [`rename`](#filter_detail_rename) | Places underscore between words then forces all characters to be lowercase. |
 | [`reverse`](#filter_detail_reverse) | Given a collection of objects, this will return a collection that has the reverse order of the input. |
 | [`sort`](#filter_detail_sort) | Given a collection of objects, this will return a collection that is sorted by name. This is useful when generating code that is consistent each time in terms of the order of objects in the output. |
 | [`title`](#filter_detail_title) | Given a string of words in camel case format, this will capitalize each word in the string except those words that are typically not capitalized in a title (such as 'of', 'the'. 'and', etc.). |
@@ -443,6 +444,25 @@ Valid inputs for this filter are:
 
 <hr/>
 
+<a name="filter_detail_rename"></a>
+##### Filter: `rename`
+
+Places underscore between words then forces all characters to be lowercase.
+
+Valid inputs for this filter are:
+
+| Class of Valid Input | Description |
+|---|---|
+| `String` | The string to change into an underscore lowercase format. |
+
+This filter has the following parameters:
+
+| Usage with Parameter | Description |
+|---|---|
+| `rename:`*method* | Specifies the renaming method: standard, underscore, underscoreLowercase, underscoreUppercase, lowercase, uppercase, capitalize, dashesLowercase, dashesUppercase, parentPrefix |
+
+<hr/>
+
 <a name="filter_detail_reverse"></a>
 ##### Filter: `reverse`
 

src/main/java/org/entityc/compiler/EntityCompiler.java

@@ -52,8 +52,8 @@
 
 public class EntityCompiler {
 
-    public static final  String              COMPILER_VERSION   = "0.15.0";
-    public static final  String              LANGUAGE_VERSION   = "0.12.6";
+    public static final  String              COMPILER_VERSION   = "0.16.0";
+    public static final  String              LANGUAGE_VERSION   = "0.13.0";
     private static final Map<String, String> defineValues       = new HashMap<>();
     private static final Set<String>         templateSearchPath = new HashSet<>();
     private static       CommandLine         commandLine;

src/main/java/org/entityc/compiler/model/domain/MTNamingMethod.java

@@ -6,6 +6,7 @@
 
 package org.entityc.compiler.model.domain;
 
+import org.entityc.compiler.util.ECLog;
 import org.entityc.compiler.util.ECStringUtil;
 
 public enum MTNamingMethod {
@@ -39,6 +40,10 @@ public static MTNamingMethod fromName(String name) {
         return null;
     }
 
+    public String getName() {
+        return name;
+    }
+
     public String getDelimiter() {
         return delimiter;
     }

src/main/java/org/entityc/compiler/transform/template/tree/filter/FTNameAsFilter.java

@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2019-2022 The EntityC Project. All rights reserved.
+ * Use of this file is governed by the BSD 3-clause license that
+ * can be found in the LICENSE.md file in the project root.
+ */
+
+package org.entityc.compiler.transform.template.tree.filter;
+
+import org.antlr.v4.runtime.ParserRuleContext;
+import org.entityc.compiler.model.domain.MTNamingMethod;
+import org.entityc.compiler.transform.template.tree.FTTransformSession;
+import org.entityc.compiler.transform.template.tree.expression.FTExpression;
+import org.entityc.compiler.transform.template.tree.expression.FTOperand;
+import org.entityc.compiler.util.ECLog;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+
+public class FTNameAsFilter extends FTFilter {
+
+    public FTNameAsFilter() {
+        super(null, "nameas",
+            "Places underscore between words then forces all characters to be lowercase.");
+        this.addFilterParam(new FTFilterParam("method",
+            "Specifies the naming method: " + String.join(", ", Arrays.stream(MTNamingMethod.values()).map(MTNamingMethod::getName).toArray(String[]::new))));
+        addSingleInputType(String.class, "The string to change into an underscore lowercase format.");
+    }
+
+    @Override
+    public Object filter(ParserRuleContext ctx, FTTransformSession session, Object input, List<FTExpression> paramValues, Map<String, Object> options) {
+        checkInput(ctx, input, paramValues, options);
+
+        if (paramValues.size() == 0) {
+            ECLog.logFatal(ctx, "Must specify a naming method. Valid values are: " + String.join(", ", Arrays.stream(MTNamingMethod.values()).map(MTNamingMethod::getName).toArray(String[]::new)));
+        }
+
+        if (input instanceof String) {
+            String inputString = (String) input;
+            FTExpression methodParam = paramValues.get(0);
+            String methodName = null;
+            if (methodParam.isOperand()) {
+                methodName = ((FTOperand) methodParam).getName();
+            }
+            else
+            {
+                ECLog.logFatal(ctx, "Naming method must be specified directly. For example: entity|nameas:uppercase");
+            }
+            MTNamingMethod namingMethod = MTNamingMethod.fromName(methodName);
+            if (namingMethod == null) {
+                ECLog.logFatal(ctx, "Unknown naming method: " + methodName);
+            }
+            return namingMethod.rename(inputString);
+        }
+
+        return null;
+    }
+}