all files / src/ origin-rules-analyse.ts

68% Statements 17/25
30% Branches 3/10
66.67% Functions 2/3
68% Lines 17/25
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77                                                                                                                        
import {ParamType} from "./enum-type";
 
export interface RealRules {
    [propName: string]: RuleItem[]
}
 
export interface RuleParam{
    type: number,
    value: any
}
 
interface RuleItem {
    method: string,
    params: RuleParam[],
    reverse: boolean
}
 
export function originRulesAnalyse(originRules: Object): RealRules {
    let realRules: RealRules = {};
 
    for (let p in originRules) {
        let ruleStr = originRules[p];
 
        updateRule(realRules, p, ruleStr);
    }
 
    return realRules;
}
 
function updateRule(rules: RealRules, propName: string, propValue: string) {
    let ruleStringList = propValue.split(/\s*\|\s*/),
        selectorSplit = propName.split(/\s*:\s*/),
        field = selectorSplit[0];
 
    Eif (rules[field] === undefined) {
        rules[field] = [];
    }
 
    let ruleItem = rules[field];
 
    for (let i = 0, len = ruleStringList.length; i < len; i++) {
        let ruleStringItem = ruleStringList[i].split(/\s*:\s*/),
            ruleParams:RuleParam[],
            methodName = ruleStringItem.splice(0, 1)[0].replace(/^\s+|\s+$/g, ''),
            isReverse = false;
 
 
        Iif (ruleStringItem.length > 0) {
            ruleParams = ruleStringItem.map(function (item) {
                let type: number;
 
                if (/^\s*['"]|['"]\s*$/.test(item) || /^-?\d+(?:\.\d+)?$/.test(item)) {
                    type = ParamType.VALUE;
                }
                else {
                    type = ParamType.PROPERTY;
                }
 
                return {
                    type: type,
                    value: item.replace(/^\s+|\s+$/g, '').replace(/^['"]|['"]$/g, '')
                };
            });
        }
 
        Iif (methodName.indexOf('!') !== -1) {
            isReverse = true;
            methodName = methodName.substr(1);
        }
 
        ruleItem.push({
            method: methodName,
            params: ruleParams,
            reverse: isReverse
        });
    }
}