• Home
• com.github.nyla-solutions
• nyla.solutions.core
• 2.2.2
• source code
• Text.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

nyla.solutions.core.util.Text Maven / Gradle / Ivy

package nyla.solutions.core.util;

import nyla.solutions.core.data.Textable;
import nyla.solutions.core.exception.FormatException;
import nyla.solutions.core.exception.RequiredException;
import nyla.solutions.core.exception.SetupException;
import nyla.solutions.core.exception.SystemException;
import nyla.solutions.core.io.IO;
import nyla.solutions.core.operations.ClassPath;
import nyla.solutions.core.patterns.decorator.BasicTextStyles;
import nyla.solutions.core.patterns.decorator.TextStyles;

import java.io.*;
import java.lang.reflect.Array;
import java.text.DecimalFormat;
import java.text.NumberFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeParseException;
import java.time.temporal.TemporalAccessor;
import java.util.*;
import java.util.function.Function;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

import static java.util.Arrays.asList;
import static nyla.solutions.core.util.Config.settings;

/**
 * 
 * Text is geared toward string based processing. It includes template engine support
 * like Free Marker that builds composite strings/values dynamically at runtime
 *  (see http://freemarker.sourceforge.net/). There are also methods to support complex
 *  regular expressions with Boolean AND, OR and NOT logic, numerous string conversions,
 *  general text manipulation and parsing methods.
 * 
 *
 * @author Gregory Green
 */

public class Text {

    /**
     * TEMPLATE_DIR_PROP_NM = Text.class.getName()+".template.dir"
     */
    public static final String TEMPLATE_DIR_PROP_NM = Text.class.getName() + ".template.dir";


    /**
     * TEMPLATE_EXTENSION_PROP_NM = Text.class.getName()+".template.extension"
     */
    public static final String TEMPLATE_EXTENSION_PROP_NM = Text.class.getName() + ".template.extension";


    /**
     * TEMPLATE_EXTENSION = settings().getProperty(TEMPLATE_EXTENSION_PROP_NM,".txt")
     */
    public static final String TEMPLATE_EXTENSION = settings().getProperty(TEMPLATE_EXTENSION_PROP_NM, ".txt");

    /**
     * TEMPLATE_CLASSPATH_ROOT = settings().getProperty(Text.class,"TEMPLATE_CLASSPATH_ROOT","templates")
     */
    public static final String TEMPLATE_CLASSPATH_ROOT = settings().getProperty(Text.class, "TEMPLATE_CLASSPATH_ROOT",
            "templates");
    /**
     * Complex matches ${NOT}
     */
    public static final String NOT = "${NOT}";
    /**
     * Complex matches ${OR}
     */
    public static final String OR = "${OR}";
    /**
     * TEMPLATE_LOCALE_COUNTRY = Text.class.getName()+".TEMPLATE_LOCALE_COUNTRY"
     */
    public static final String TEMPLATE_LOCALE_COUNTRY = Text.class.getName() + ".TEMPLATE_LOCALE_COUNTRY";
    /**
     * TEMPLATE_LOCALE_LANGUAGE = Text.class.getName()+".TEMPLATE_LOCALE_LANGUAGE"
     */
    public static final String TEMPLATE_LOCALE_LANGUAGE = Text.class.getName() + ".TEMPLATE_LOCALE_LANGUAGE";
    /**
     * SPECIAL_START = "${START}" used for the parse method (start tag)
     */
    public static final String SPECIAL_START = "${START}";
    /**
     * SPECIAL_END = "${END} used for the parse method (end tag)
     */
    public static final String SPECIAL_END = "${END}";
    /**
     * dateFormat = settings().getProperty(Text.class,"dateFormat", "MM/dd/yyyy")
     */
    public static final String DATETIME_FORMAT = settings().getProperty(Text.class, "dateFormat", "M/dd/yyyy hh:mm:ss:SS " +
            "a");
    public static final String DATE_FORMAT = settings().getProperty(Text.class, "dateFormat", "M/dd/yyyy");
    //private static final String encoding = settings().getProperty(Text.class,"encoding","ISO-8859-1");
    private static final Random random = new Random(Calendar.getInstance().getTime().getTime());
    private static final String[] fixedNumberPrefixLookup =
            {
                    "0", "00", "000", "0000", "00000", "000000", "0000000", "00000000", "000000000", "0000000000"
            };
    /**
     * Complex matches and
     */
    private static final String AND = "${AND}";
    private static TextStyles textStyles = null;

    /**
     * Append newline to text
     *
     * @param text the text
     * @return the text with the appended the new line
     */
    public static String appendNewLine(String text) {

        String newline = IO.newline();

        if (text == null || text.isEmpty())
            return newline;

        StringBuilder sb = new StringBuilder(text);

        if (!text.endsWith(newline)) {
            sb.append(newline);
        }

        return sb.toString();
    }

    /**
     * Inject an with the property solutions.global.util.Text.textStyles=className
     *
     * @return implementation of  text styles
     */
    public static TextStyles getTextStyles() {
        if (textStyles == null) {
            String className = settings().getProperty(Text.class, "textStyles", BasicTextStyles.class.getName());

            try {
                textStyles = ClassPath.newInstance(className);
            } catch (Exception e) {
                throw new SetupException("Unable to create TextStyles instance:" + className, e);
            }
        }

        return textStyles;

    }

    public static String fixedLength(int number, int length) {
        String numberText = String.valueOf(number);
        int numberLength = numberText.length();

        StringBuilder sb = new StringBuilder();

        if (length > 16) {
            sb.ensureCapacity(length);
        }

        sb.append(numberText);

        //prefix 0
        if (length == numberLength)
            return sb.toString();


        if (numberLength > length) {
            sb.setLength(length);
            return sb.toString();
        }

        int diff = length - numberLength;

        if (diff < fixedNumberPrefixLookup.length) {
            sb.insert(0, fixedNumberPrefixLookup[diff - 1]);
            return sb.toString();
        }

        //prefix 0(s) =
        //length = 2 and value = 1 = 01

        for (int i = 0; i < length - numberLength; i++) {
            sb.insert(0, "0");
        }

        return sb.toString();
        
    }

    public static String fixedLength(String text, int length) {
        StringBuilder sb = new StringBuilder(length);

        sb.append(text);
        sb.setLength(length);
        return sb.toString();

    }

    public static String fixedLength(String text, int length, char fillChar) {

        StringBuilder sb = new StringBuilder(length);
        sb.append(text);
        sb.setLength(length);

        //Take original
        if (fillChar != '\0') {
            //replace with prefix
            int originalLength = text.length();

            if (originalLength < sb.length()) {
                String newEnd = sb.substring(originalLength, sb.length()).replace('\0', fillChar);
                sb = sb.replace(originalLength, sb.length(), newEnd);
            }

        }

        return sb.toString();

    }

    /**
     * Loop thrus map to formats any needed value with data from other properties.
     * 

     * See Text.format(String,Map)
     *
     * @param map the map to format
     * @throws FormatException when format error occurs
     */
    public static void formatMap(Map map)
            throws FormatException {
        if (map == null || map.isEmpty())
            return;// nothing to process

        //format properties
        Object key, value;
        String text;

        for (Map.Entry entry : map.entrySet()) {
            key = entry.getKey();
            value = entry.getValue();

            if (!(value instanceof String))
                continue; //skip

            text = (String) value;

            //overwrite value with formatted version
            if (text.contains("${"))
                map.put(key, Text.format(text, map));
        }

    }

    /**
     * Generate a unique ID
     *
     * @return the generated ID
     */
    public static String generateId() {
        var date = Calendar.getInstance().getTime();

        var dateId = formatDate("yyyyMMddHHmmssSS", date);

        return dateId + random.nextInt();

    }

    /**
     * End all line with \r\n
     *
     * @param s string to replace
     * @return the converted newline
     */
    public static String newlineToCrLf(String s) {
        String s1 = s.replaceAll("\\r", "");
        return s1.replaceAll("\\n", "\r\n");
    }

    /**
     * @param lines tokens separated by \t\n\r
     * @return tokens separated by \n (newline)
     */
    public static Set toSet(String[] lines) {
        return new TreeSet(asList(lines));
    }

    public static String removeNewLines(String text) {
        return replace("\r\n", " ", text);
    }

    /**
     * @param aValue the value
     * @param aType  the type of the value
     * @return value cast to the object type instance
     */
    public static Object toObject(String aValue, String aType) {
        if ("Date".equalsIgnoreCase(aType)) {
            return toDate(aValue);
        } else if ("Boolean".equalsIgnoreCase(aType)) {
            return Boolean.valueOf(aValue);
        } else if ("Int".equalsIgnoreCase(aType) ||
                "Integer".equalsIgnoreCase(aType)) {
            return Integer.valueOf(aValue);
        } else if ("Double".equalsIgnoreCase(aType)) {
            return Double.valueOf(aValue);
        } else {
            return aValue;
        }

    }

    /**
     * Use a regular expression to update a given text
     *
     * @param text        the text to update
     * @param re          the regular expression
     * @param replaceText the replacement text
     * @return the formatted regular expression
     */
    public static String replaceForRegExprWith(final String text, final String re, final String replaceText) {
        if (text == null || text.isEmpty())
            return "";

        Pattern pattern = Pattern.compile(re);

        return pattern.matcher(text).replaceAll(replaceText);

    }

    /**
     * Parse text based on regular expressions
     * TODO: add multiple results
     *
     * @param startRE the start regular express
     * @param endRE   the end regular expression
     * @param text    the text to parse
     * @return the parsed output
     */
    public static String parseRE(String text, String startRE, String endRE) {
        try {
            if (text == null || text.isEmpty())
                return text;

            if (startRE == null || endRE == null)
                return text;

            Pattern startPattern = Pattern.compile(startRE);
            Pattern endPattern = Pattern.compile(endRE);

            Matcher startMatcher = startPattern.matcher(text);

            if (!startMatcher.find())
                return text;

            int startIndex = startMatcher.end();

            String endText = text.substring(startIndex);

            Matcher endMatcher = endPattern.matcher(endText);
            if (!endMatcher.find())
                return text.substring(startIndex);

            int endIndex = endMatcher.start();

            if (endIndex < 0)
                endIndex = endText.length() - 1;

            return text.substring(startIndex, startIndex + endIndex);
        } catch (IllegalStateException e) {
            throw new SystemException("startRE=" + startRE + " endRE=" + endRE + " text=" + text + " " + Debugger.stackTrace(e));
        }
    }

    /**
     * Replace the last instance of the regular expression with a given token
     *
     * @param text        the source text
     * @param re          the regular expression
     * @param replacement the replacement text
     * @return the text with the last regExpr instance replaced
     */
    public static String replaceFirstRegExpWith(String text, String re, String replacement) {
        if (text == null || text.isEmpty())
            return "";

        //compile pattern
        Pattern pattern = Pattern.compile(re);

        return pattern.matcher(text).replaceFirst(replacement);

    }

    /**
     * @param object to convert collection of String to array
     * @return the array of strings
     */
    @SuppressWarnings("unchecked")
    public static String[] toStrings(Object object) {
        if (object == null)
            return null;


        if (object instanceof Collection) {
            return toStrings((Collection