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

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

95.65% Statements 22/23
75% Branches 6/8
100% Functions 1/1
95.65% Lines 22/23

    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
    111
    112
    113
    114
    115
    1161x

    1x

    1x

    1x
    1x
    1x

    1x

    1x

    522x

    522x
    522x

    522x
    522x
    522x

    522x
    3x

    519x

    35557x

    519x

    519x

    9104x

    519x

     import 'format-unicorn';

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

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

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

    import { UnicodeArray } from '../../UnicodeArray';

    import { UnicodeArrayTemplate } from '../../templates/custom-nodes/unicode-array-nodes/unicode-array-node/UnicodeArrayTemplate';

    import { AbstractCustomNode } from '../AbstractCustomNode';
    import { NodeAppender } from '../../NodeAppender';
    import { NodeUtils } from '../../NodeUtils';

    export class UnicodeArrayNode extends AbstractCustomNode {
        /**
         * @type {number}
         */
        public static UNICODE_ARRAY_RANDOM_LENGTH: number = 4;

        /**
         * @type {AppendState}
         */
        protected appendState: AppendState = AppendState.AfterObfuscation;

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

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

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

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

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

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

            NodeAppender.prependNode(blockScopeNode, this.getNode());
        }

        /**
         * @returns {string}
         */
        public getNodeIdentifier (): string {
            return this.unicodeArrayName;
        }

        /**
         * @returns {UnicodeArray}
         */
        public getNodeData (): UnicodeArray {
            return this.unicodeArray;
        }

        /**
         * @returns {TStatement[]}
         */
        public getNode (): TStatement[] {
            this.unicodeArray.rotateArray(this.unicodeArrayRotateValue);

            return super.getNode();
        }

        /**
         * @param data
         */
        public updateNodeData (data: string): void {
            this.unicodeArray.addToArray(data);
        }

        /**
         * @returns {TStatement[]}
         */
        protected getNodeStructure (): TStatement[] {
            return NodeUtils.convertCodeToStructure(
                UnicodeArrayTemplate().formatUnicorn({
                    unicodeArrayName: this.unicodeArrayName,
                    unicodeArray: this.unicodeArray.toString()
                })
            );
        }
    }