Code coverage report for src/custom-nodes/unicode-array-nodes/StringArrayRotateFunctionNode.ts

# All files / src/custom-nodes/unicode-array-nodes StringArrayRotateFunctionNode.ts

96.3% Statements 26/27
66.67% Branches 4/6
100% Functions 1/1
96.3% Lines 26/27

    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
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    1111x

    1x

    1x

    1x
    1x

    1x
    1x
    1x
    1x

    1x

    1x

    508x

    508x

    508x
    508x
    508x

    508x

    508x

    508x

    508x
    508x
    508x

    508x
    502x

    6x

    508x

     import 'format-unicorn';

    import { TNodeWithBlockStatement } from '../../types/TNodeWithBlockStatement';
    import { TStatement } from '../../types/TStatement';

    import { IOptions } from '../../interfaces/IOptions';

    import { AppendState } from '../../enums/AppendState';

    import { NO_CUSTOM_NODES_PRESET } from '../../preset-options/NoCustomNodesPreset';

    import { SelfDefendingTemplate } from '../../templates/custom-nodes/unicode-array-nodes/unicode-array-rotate-function-node/SelfDefendingTemplate';
    import { UnicodeArrayRotateFunctionTemplate } from '../../templates/custom-nodes/unicode-array-nodes/unicode-array-rotate-function-node/UnicodeArrayRotateFunctionTemplate';

    import { AbstractCustomNode } from '../AbstractCustomNode';
    import { JavaScriptObfuscator } from '../../JavaScriptObfuscator';
    import { NodeAppender } from '../../NodeAppender';
    import { NodeUtils } from '../../NodeUtils';
    import { UnicodeArray } from '../../UnicodeArray';
    import { Utils } from '../../Utils';

    export class UnicodeArrayRotateFunctionNode extends AbstractCustomNode {
        /**
         * @type {AppendState}
         */
        protected appendState: AppendState = AppendState.AfterObfuscation;

        /**
         * @type {UnicodeArray}
         */
        private unicodeArray: UnicodeArray;

        /**
         * @type {string}
         */
        private unicodeArrayName: string;

        /**
         * @param {number}
         */
        private unicodeArrayRotateValue: number;

        /**
         * @param unicodeArrayName
         * @param unicodeArray
         * @param unicodeArrayRotateValue
         * @param options
         */
        constructor (
            unicodeArrayName: string,
            unicodeArray: UnicodeArray,
            unicodeArrayRotateValue: number,
            options: IOptions
        ) {
            super(options);

            this.unicodeArrayName = unicodeArrayName;
            this.unicodeArray = unicodeArray;
            this.unicodeArrayRotateValue = unicodeArrayRotateValue;
        }

        /**
         * @param blockScopeNode
         */
        public appendNode (blockScopeNode: TNodeWithBlockStatement): void {
            Iif (!this.unicodeArray.getLength()) {
                return;
            }

            NodeAppender.insertNodeAtIndex(blockScopeNode, this.getNode(), 1);
        }

        /**
         * @returns {TStatement[]}
         */
        public getNode (): TStatement[] {
            return super.getNode();
        }

        /**
         * @returns {TStatement[]}
         */
        protected getNodeStructure (): TStatement[] {
            let code: string = '',
                timesName: string = Utils.getRandomVariableName(),
                whileFunctionName: string = Utils.getRandomVariableName();

            if (this.options.selfDefending) {
                code = SelfDefendingTemplate().formatUnicorn({
                    timesName,
                    whileFunctionName
                });
            } else {
                code = `${whileFunctionName}(++${timesName})`;
            }

            return NodeUtils.convertCodeToStructure(
                JavaScriptObfuscator.obfuscate(
                    UnicodeArrayRotateFunctionTemplate().formatUnicorn({
                        code,
                        timesName,
                        unicodeArrayName: this.unicodeArrayName,
                        unicodeArrayRotateValue: Utils.decToHex(this.unicodeArrayRotateValue),
                        whileFunctionName
                    }),
                    NO_CUSTOM_NODES_PRESET
                ).getObfuscatedCode()
            );
        }
    }