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

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

100% Statements 31/31
100% Branches 2/2
100% Functions 1/1
100% Lines 28/28

    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
    1081x
    1x

    1x

    1x

    1x

    1x
    1x

    1x
    1x
    1x
    1x
    1x

    1x

    1x

    1x

    1x

    731x

    731x
    731x
    731x

    713x

    713x
    713x

    713x

    713x
    1x

    712x

    713x

     import { injectable, inject } from 'inversify';
    import { ServiceIdentifiers } from '../../container/ServiceIdentifiers';

    import * as format from 'string-template';

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

    import { IOptions } from '../../interfaces/options/IOptions';
    import { IStorage } from '../../interfaces/storages/IStorage';

    import { initializable } from '../../decorators/Initializable';

    import { NO_CUSTOM_NODES_PRESET } from '../../options/presets/NoCustomNodes';

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

    import { AbstractCustomNode } from '../AbstractCustomNode';
    import { JavaScriptObfuscator } from '../../JavaScriptObfuscator';
    import { NodeUtils } from '../../node/NodeUtils';
    import { RandomGeneratorUtils } from '../../utils/RandomGeneratorUtils';
    import { Utils } from '../../utils/Utils';

    @injectable()
    export class StringArrayRotateFunctionNode extends AbstractCustomNode {
        /**
         * @type {IStorage <string>}
         */
        @initializable()
        private stringArrayStorage: IStorage <string>;

        /**
         * @type {string}
         */
        @initializable()
        private stringArrayName: string;

        /**
         * @param {number}
         */
        @initializable()
        private stringArrayRotateValue: number;

        /**
         * @param options
         */
        constructor (
            @inject(ServiceIdentifiers.IOptions) options: IOptions
        ) {
            super(options);
        }

        /**
         * @param stringArrayStorage
         * @param stringArrayName
         * @param stringArrayRotateValue
         */
        public initialize (
            stringArrayStorage: IStorage <string>,
            stringArrayName: string,
            stringArrayRotateValue: number
        ): void {
            this.stringArrayStorage = stringArrayStorage;
            this.stringArrayName = stringArrayName;
            this.stringArrayRotateValue = stringArrayRotateValue;
        }

        /**
         * @returns {TStatement[]}
         */
        protected getNodeStructure (): TStatement[] {
            return NodeUtils.convertCodeToStructure(this.getTemplate());
        }

        /**
         * @returns {string}
         */
        protected getTemplate (): string {
            const timesName: string = RandomGeneratorUtils.getRandomVariableName(6);
            const whileFunctionName: string = RandomGeneratorUtils.getRandomVariableName(6);

            let code: string = '';

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

            return JavaScriptObfuscator.obfuscate(
                format(StringArrayRotateFunctionTemplate(), {
                    code,
                    timesName,
                    stringArrayName: this.stringArrayName,
                    stringArrayRotateValue: Utils.decToHex(this.stringArrayRotateValue),
                    whileFunctionName
                }),
                {
                    ...NO_CUSTOM_NODES_PRESET,
                    seed: this.options.seed
                }
            ).getObfuscatedCode();
        }
    }