Showing posts with label string from regular expression. Show all posts
Showing posts with label string from regular expression. Show all posts

Saturday, November 23, 2013

java convert regular expression into string

It is easy to check a string with regular expression, but there is no direct method to generate string from regular expression. I hardly need it but found nothing. So I myself generated the following program to generate string using regular expression and check back the string with given regular expression. The program i generated will sufficient for normal expression. It will cover my back. It will not parse high level expression.

Output example using random regex generator


Regex: [a-z][a-z0-9]{8,10}@[a-z0-9]{5,9}.com
Matches: [a-z][a-z0-9]{8,10}@[a-z0-9]{5,9}.com, String: bak65qvkpp@3qosue.com, Length: 21



Regex: [\w][\D]{0,10}[\d\W]{1,10}[abc.][abc09]{1,10}
Matches: [\w][\D]*[\d\W]+[abc.][abc09]+, String: aLchJL,e’‘.c9bca, Length: 16



Regex: [A-Z]{4}-#%[\d]{3}
Matches: [A-Z]{4}-#%[\d]{3}, String: BAKZ-#%114, Length: 10



Regex: www.[a-z][a-z0-9-_]{5,15}[a-z].com
Matches: www.[a-z][a-z0-9-_]{5,15}[a-z].com, String: www.jj829x10cq9ngilk.com, Length: 24



Regex: 01[7856][0-9]{2}-[0-9]{6}
Matches: 01[7856][0-9]{2}-[0-9]{6}, String: 01700-736202, Length: 12

StringRegex.java (main class)


import java.util.Random;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 *
 * @author Pritom K Mondal
 * @version 1.0
 */
public class StringRegex {
    public static void main(String[] args) {
        String regex = "[a-z][a-z0-9]{8,10}@[a-z0-9]{5,9}.com";
        StringRegex.stringFromRegex(regex);
        regex = "[\\w][\\D]*[\\d\\W]+[abc.][abc09]+";
        StringRegex.stringFromRegex(regex);
        regex = "[A-Z]{4}-#%[\\d]{3}";
        StringRegex.stringFromRegex(regex);
        regex = "www.[a-z][a-z0-9-_]{5,15}[a-z].com";
        StringRegex.stringFromRegex(regex);
        regex = "01[7856][0-9]{2}-[0-9]{6}";
        StringRegex.stringFromRegex(regex);
    }
    
    public static void stringFromRegex(String regex) {         
        String regexConverted = cvtLineTerminators(regex);
        System.out.println("Regex: " + regexConverted);
        String fullString = "";
        fullString = parse(regexConverted, "");
        if(fullString.matches(regex)) {
            System.out.println("Matches: " + regex + ", String: " + fullString + ", Length: " + fullString.length());
        } else {
            System.err.println("Matches Failed: " + regex + ", String: " + fullString + ", :Length: " + fullString.length());
        }
        System.out.println("\n\n");
    }
    
    private static String parse(String regex, String fullString) {
        Random random = new Random();
        if(regex.trim().length() > 0) {
            Boolean allow = false, processed = false;
            if(regex.startsWith("[") 
                    && (regex.substring(0, regex.indexOf("]") + 1).matches("(.*)[a-z]\\-[a-z](.*)") 
                    || regex.substring(0, regex.indexOf("]") + 1).matches("(.*)[A-Z]\\-[A-Z](.*)") 
                    || regex.substring(0, regex.indexOf("]") + 1).matches("(.*)d(.*)") 
                    || regex.substring(0, regex.indexOf("]") + 1).matches("(.*)D(.*)") 
                    || regex.substring(0, regex.indexOf("]") + 1).matches("(.*)w(.*)") 
                    || regex.substring(0, regex.indexOf("]") + 1).matches("(.*)W(.*)") 
                    || regex.substring(0, regex.indexOf("]") + 1).matches("\\[([a-z]*)([0-9]*).\\]") 
                    || regex.substring(0, regex.indexOf("]") + 1).matches("\\[[A-Z].\\]") 
                    || regex.substring(0, regex.indexOf("]") + 1).matches("(.*)[0-9]\\-[0-9](.*)"))) {
                allow = true;
            }
            if(allow) {
                int start = regex.indexOf("[");
                int end = regex.indexOf("]", start);
                String part = regex.substring(start, end + 1);
                regex = regex.substring(end + 1);
                int pos1 = 1, pos2 = 1;
                if(regex.startsWith("{")) {
                    start = 0;
                    String pos = "";
                    end = regex.indexOf("}", start);
                    pos = regex.substring(start + 1, end);
                    //part = part + regex.substring(start, end + 1);
                    regex = regex.substring(end + 1);
                    
                    if(pos.trim().length() > 0) {
                        if(pos.contains(",")) {
                            String[] poss = pos.split(",");
                            pos1 = Integer.parseInt(poss[0]);
                            pos2 = Integer.parseInt(poss[1]);
                        } else {
                            pos1 = Integer.parseInt(pos);
                            pos2 = Integer.parseInt(pos);
                        }
                    }
                }
                //System.out.println("Pos: " + pos1 + " to " + pos2);
                
                StringBuilder sb = new StringBuilder();                
                String str = "";
                String printInfo = "Processing-1: " + part;
                int tried = 0;
                while(sb.toString().length() == 0 && tried <= 5) {
                    tried++;
                    str = RandomString.nextString(2000);
                    try {
                        Matcher m = Pattern.compile(part).matcher(str);
                        while (m.find()) {
                            sb.append(m.group(0).toString());
                        }
                    } catch (Exception ex) {
                        System.out.println("Exception: " + ex.getMessage());
                    }
                }
                if(sb.toString().length() > 0) {
                    processed = true;
                    str = sb.toString();
                    while(true) {
                        if(str.length() < pos2) {
                            str = str.concat(str);
                        } else {
                            break;
                        }
                    }
                    printInfo += " = (" + pos1 + ", " + pos2 + "): ";
                    String cutString = str.substring(0, pos1);
                    if(pos2 - pos1 > 0) {
                        pos2 = random.nextInt(pos2 - pos1);
                        cutString += str.substring(pos1, pos2 + pos1);
                    }
                    printInfo += cutString;
                    //System.out.println(printInfo);
                    fullString += cutString;
                } else {
                    regex = part + regex;
                }
            } 
            if(regex.startsWith("[") && !processed) {
                processed = true;
                int start = regex.indexOf("[");
                int end = regex.indexOf("]", start);
                String part = regex.substring(start + 1, end);
                regex = regex.substring(end + 1);
                String printInfo = "Processing-2: " + part;
                int pos1 = 1, pos2 = 1;
                if(regex.startsWith("{")) {
                    start = 0;
                    String pos = "";
                    end = regex.indexOf("}", start);
                    pos = regex.substring(start + 1, end);
                    regex = regex.substring(end + 1);
                    
                    if(pos.trim().length() > 0) {
                        if(pos.contains(",")) {
                            String[] poss = pos.split(",");
                            pos1 = Integer.parseInt(poss[0]);
                            pos2 = Integer.parseInt(poss[1]);
                        } else {
                            pos1 = Integer.parseInt(pos);
                            pos2 = Integer.parseInt(pos);
                        }
                    }
                }
                String pushString = "";
                for(int i = 0; i < pos1; i++) {
                    pushString += part;
                }
                if(pos2 - pos1 > 0) {
                    pos2 = random.nextInt(pos2 - pos1);
                    for(int i = 0; i < pos2; i++) {
                        pushString += part;
                    }
                }
                printInfo += "{" + pos1 + "," + pos2 + "} = " + pushString;
                //System.out.println(printInfo);
                fullString += pushString;
            } 
            if(!processed) {
                //System.out.println("Handled: " + regex);
                regex = "[" + regex;
                int fa = regex.indexOf("]"), f2 = regex.indexOf("{"), f3 = regex.indexOf("[", 1);
                if(fa > f3) fa = f3;
                if(fa > f2) fa = f2;
                if(fa < 0) {
                    if(f2 < f3 && f2 >= 0) {
                        fa = f2;
                    } else if(f3 > f2 && f3 >= 0) {
                        fa = f3;
                    } else {
                        fa = regex.length();
                    }
                }
                //regex = regex.substring(0, fa) + "]" + regex.substring(fa);
                regex = regex.substring(0, 2) + "]" + regex.substring(2);
                //System.out.println("Handled: " + regex);
            }
            fullString = parse(regex, fullString);
        }
        return fullString;
    }
    
    private static String cvtLineTerminators (String s) {
        s = s.replaceAll("\\*", "{0,10}");
        s = s.replaceAll("\\+", "{1,10}");
        
        StringBuffer sb = new StringBuffer ();
        int oldindex = 0, newindex;
        while ((newindex = s.indexOf ("\\n", oldindex)) != -1) {
            sb.append (s.substring (oldindex, newindex));
            oldindex = newindex + 2;
            sb.append ('\n');
        }
        sb.append (s.substring (oldindex));

        s = sb.toString ();
        sb = new StringBuffer ();
        oldindex = 0;
        while ((newindex = s.indexOf ("\\r", oldindex)) != -1) {
            sb.append (s.substring (oldindex, newindex));
            oldindex = newindex + 2;
            sb.append ('\r');
        }
        sb.append (s.substring (oldindex));

        s = sb.toString ();
        sb = new StringBuffer ();
        oldindex = 0;
        while ((newindex = s.indexOf ("\\s", oldindex)) != -1) {
            sb.append (s.substring (oldindex, newindex));
            oldindex = newindex + 2;
            sb.append (" ");
        }
        sb.append (s.substring (oldindex));
        
        return sb.toString();
   }
}

RandomString.java


import java.util.Random;

/**
 *
 * @author Pritom K Mondal
 */
public class RandomString {
    private static final char[] symbols = new char[10 + 26 + 26 + 3 + 8];
    private static final char[] chars = new char[52];
    private static final char[] numbers = new char[10];
    
    static {
        for (int idx = 0; idx < 10; ++idx) {
            numbers[idx] = (char) ('0' + idx);
        }
        for (int idx = 10; idx < 36; ++idx) {
            chars[idx - 10] = (char) ('a' + idx - 10);
        }
        for (int idx = 36; idx < 62; ++idx) {
            chars[idx - 10] = (char) ('A' + idx - 36);
        }
        /**
         * String
         */
        int total = 0;
        for(int idx = 48; idx <= 57; idx++, total++) {
            symbols[total] = (char) idx;
        }// 10 (10)
        for(int idx = 65; idx <= 90; idx++, total++) {
            symbols[total] = (char) idx;
        } // 26 (36)
        for(int idx = 97; idx <= 122; idx++, total++) {
            symbols[total] = (char) idx;
        } // 26 (62)
        for(int idx = 44; idx <= 46; idx++, total++) {
            symbols[total] = (char) idx;
        } // 3 (65)
        int[] copyFrom = { 64, 95, 44, 46, 45, 145, 146, 35 };
                         //@   _   ,   .   -   ‘     ’    #
        for(int idx = 0; idx < copyFrom.length; idx++, total++) {
            symbols[total] = (char) copyFrom[idx];
        } // 8 (73)
        //System.out.println(total);
    }
    
    private static Random random = new Random();
    private static char[] buf;
    
    public static String fullString() {
        return new String(symbols);
    }
    
    public static String nextString(int length) {
        if (length < 1) {
            throw new IllegalArgumentException("length < 1: " + length);
        }
        buf = new char[length];
        //System.out.println(symbols);
        for (int idx = 0; idx < buf.length; ++idx) {
            buf[idx] = symbols[random.nextInt(symbols.length)];
        }
        return new String(buf);
    }
    
    public static String nextNumber(int length) {
        if (length < 1) {
            throw new IllegalArgumentException("length < 1: " + length);
        }
        buf = new char[length];
        for (int idx = 0; idx < buf.length; ++idx) {
            buf[idx] = numbers[random.nextInt(numbers.length)];
        }
        return new String(buf);
    }
    
    public static String nextCharacter(int length) {
        if (length < 1) {
            throw new IllegalArgumentException("length < 1: " + length);
        }
        buf = new char[length];
        for (int idx = 0; idx < buf.length; ++idx) {
            buf[idx] = chars[random.nextInt(chars.length)];
        }
        return new String(buf);
    }
}