Cleanse your camel

camel_case_refactor.hx

Test file:
package;
import CamelCaseTest;
class CamelCaseTest<
    ChildType:(ChildI<ChildParentType>,DataObject),
    ChildParentType:DataObject,
    ChildrenArrayType:ChildArray<ChildType,ChildParentType>
> {
    var children(children_get,null):ChildrenArrayType;
  var var_test:CamelCaseTest;
	public function new() {
	}
	public function test():Void {
		CamelCaseTest.static_test();
	}
	public static inline function static_test():CamelCaseTest {
		
	}
}

package;
import ds.Array_g;
import sys.FileSystem;
class Utils_sys {
    public static function recur_dirs(dirs:Array_g<String>,?file_handler:Dynamic,?dir_handler:Dynamic):Void {
        for(dir in dirs) {
            recur_dir(dir,file_handler,dir_handler);
        }
    }
    public static function recur_dir(dir:String,?file_handler:Dynamic,?dir_handler:Dynamic):Void {
        var leafs:Array<String>=FileSystem.readDirectory(dir);
        for(leaf in leafs) {
            var leaf_dir:String=dir+"/"+leaf;
            if(FileSystem.isDirectory(leaf_dir)) {
                if(dir_handler!=null) {
                    dir_handler(leaf_dir);
                }
                recur_dir(leaf_dir,file_handler,dir_handler);
            } else {
                file_handler(leaf_dir);
            }
        }
    }
    public static function dir_create(dir:String):Void {
        if(!FileSystem.exists(dir)) {
            try {
                FileSystem.createDirectory(dir);
            } catch(e:Dynamic) {
                dir_create(dir.substring(0,dir.lastIndexOf("/")));
                FileSystem.createDirectory(dir);
            }
        }
    }
}


public var src_dirs:Array_g<String>;
public function files_refactor():Void {
    src_dirs=new Array_g<String>();
    src_dirs.ar=[
        "s:/_flash/refactor/test"
    ];
    camel_case_file_refactor("s:/_flash/refactor/test/CamelCaseTest.hx");
}
function camel_case_string_change(s:String):String {
    var s_new:String=null;
    var reg:EReg=new EReg("(([A-Z][a-z]*)|([0-9][A-Za-z0-9]*)|([a-z][a-z0-9]*))","");
    var matcher:Matcher=new Matcher(s,reg);
    var words_first:Bool=true;
    while(matcher.find()) {
        var word:String=matcher.reg.matched(1);
        if(words_first) {
            words_first=false;
            s_new=word;
        } else {
            if(s_new.charAt(s_new.length-1)!="_" && word.charAt(0)!="_") {
                s_new+="_";
            }
            s_new+=word.toLowerCase();
        }
    }
    return s_new;
}
function camel_case_file_refactor(file:String):Bool {
    var hx_reg:EReg=new EReg("([A-Za-z0-9_]+)\\.hx$","");
    var file_type_name_old:String=null;
    if(!hx_reg.match(file)) {
        return false;
    } else {
        file_type_name_old=hx_reg.matched(1);
    }
    var r:Bool=false;
    var file_type_name_new:String=null;
    var content:String=File.getContent(file);
    trace(file);
    var types_reg:EReg=new EReg("(?:class|typedef|interface|enum)\\s([A-Za-z0-9_]+)","");
    var types_matcher:Matcher=new Matcher(content,types_reg);
    while(types_matcher.find()) {
        var class_name_old:String=types_matcher.reg.matched(1);
        trace(class_name_old);
        var class_name_new:String=camel_case_string_change(class_name_old);
        //(?=([A-Z])|(_![0-9])|$)
        trace(class_name_new);
        if(class_name_old!=class_name_new) {
            trace("diff");
            r=true;
            Utils_sys.recur_dirs(src_dirs,callback(file_type_change,_,class_name_old,class_name_new));
            if(class_name_old==file_type_name_old) {
                file_type_name_new=class_name_new;
            }
        }
    }
    content=File.getContent(file);
    var params_reg:EReg=new EReg("(?:class|interface)\\s+[A-Za-z0-9_]+\\s*<([A-Za-z0-9_,:\\)\\(><\\s]+?>)\\s+(?:extends|implements|{)","s");
    trace("params_reg exec");
    if(params_reg.match(content)) {
        trace("params_reg match");
        var params_s:String=params_reg.matched(1);
        trace(params_s);
        var param_reg:EReg=new EReg("([A-Za-z0-9_]+?)(,|:|>)","");
        var pos:{pos:Int,len:Int}=null;
        var delim:String=null;
        var param:String=null;
        var param_new:String=null;
        while(param_reg.match(params_s)) {
            param=param_reg.matched(1);
            param_new=camel_case_string_change(param);
            trace(param+" "+param_new);
            if(param!=param_new) {
                file_type_change(file,param,param_new);
            }
            delim=param_reg.matched(2);
            pos=param_reg.matchedPos();
            params_s=params_s.substr(pos.len);
            if(delim==":") {
                var brackets_num:Int=0;
                var paren_num:Int=0;
                var constraints_reg:EReg=new EReg("(?:[A-Za-z0-9_]*)(,|<|>|\\)|\\()","");
                var constraints_delim:String=null;
                while(true) {
                    constraints_reg.match(params_s);
                    pos=constraints_reg.matchedPos();
                    params_s=params_s.substr(pos.pos+pos.len);
                    trace(params_s);
                    constraints_delim=constraints_reg.matched(1);
                    if(constraints_delim==",") {
                        if(brackets_num==0 && paren_num==0) {
                            break;
                        }
                    } else if(constraints_delim=="<") {
                        brackets_num++;
                    } else if(constraints_delim==">") {
                        if(brackets_num==0) {
                            break;
                        } else {
                            brackets_num--;
                        }
                    } else if(constraints_delim=="(") {
                        paren_num++;
                    } else if(constraints_delim==")") {
                        paren_num--;
                    }
                }
            } else if(delim==">") {
                break;
            }
        }
    }
    if(file_type_name_new!=null) {
        var file_new:String=Path.directory(file)+"/"+file_type_name_new+".hx";
        trace(file_new);
        FileSystem.rename(file,file_new);
    }
    return r;
}
function type_change(content:String,type_name_old:String,type_name_new:String):String {
    var content_new:String=content;
    var reg:EReg=new EReg("((?:class|typedef|interface|new|extends|implements)\\s+?)"+type_name_old+"([^A-Za-z0-9_])","g");
    content_new=reg.replace(content_new,"$1"+type_name_new+"$2");

    var import_reg:EReg=new EReg("(import .*?)"+type_name_old+"(\\s*?;)","g");
    content_new=import_reg.replace(content_new,"$1"+type_name_new+"$2");

    var static_reg:EReg=new EReg("(\\s)"+type_name_old+"(\\.)","g");
    content_new=static_reg.replace(content_new,"$1"+type_name_new+"$2");

    var type_reg:EReg=new EReg("(:\\s*?)"+type_name_old+"([^A-Za-z0-9_])","g");
    content_new=type_reg.replace(content_new,"$1"+type_name_new+"$2");

    var gen_reg:EReg=new EReg("((?:<|,|:|\\()\\s*?)"+type_name_old+"(\\s*?(?:>|<|:|,|\\)))","sg");
    content_new=gen_reg.replace(content_new,"$1"+type_name_new+"$2");

    trace(content_new);
    return content_new;
}
function file_type_change(file:String,type_name_old:String,type_name_new:String):Bool {
    var r:Bool=false;
    var content:String=File.getContent(file);
    var content_new:String=type_change(content,type_name_old,type_name_new);
    if(content_new!=content) {
        trace("class_name_change "+file+" "+type_name_old+" "+type_name_new);
        File.saveContent(file,content_new);
        r=true;
    }
    return r;
}