FrenchYeti/dexcalibur

View on GitHub

Showing 948 of 948 total issues

Similar blocks of code found in 7 locations. Consider refactoring.
Open

    static fromXml(xmlobj){
        let o = new IntentDataCriteria();

        for(let i in xmlobj){
            if(i.startsWith('android:')){
Severity: Major
Found in src/AndroidAppComponents.js and 6 other locations - About 1 hr to fix
src/AndroidAppComponents.js on lines 319..331
src/AndroidAppComponents.js on lines 355..367
src/AndroidAppComponents.js on lines 438..450
src/AndroidAppComponents.js on lines 479..491
src/AndroidAppComponents.js on lines 503..515
src/AndroidAppComponents.js on lines 539..551

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

Tuning

This issue has a mass of 92.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Further Reading

Identical blocks of code found in 2 locations. Consider refactoring.
Open

            for(let i=0; i<config.method.length; i++){
                config.custom = true;
                primitive = new HookPrimitive(config);
                primitive.isIntercept = true;
                primitive.isCustom = true;
Severity: Major
Found in src/HookManager.js and 1 other location - About 1 hr to fix
src/HookManager.js on lines 1939..1948

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

Tuning

This issue has a mass of 92.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Further Reading

Identical blocks of code found in 2 locations. Consider refactoring.
Open

        }else{
            config.custom = true;
            primitive = new HookPrimitive(config);
            primitive.isIntercept = true;
            primitive.isCustom = true;
Severity: Major
Found in src/HookManager.js and 1 other location - About 1 hr to fix
src/HookManager.js on lines 1929..1938

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

Tuning

This issue has a mass of 92.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Further Reading

Similar blocks of code found in 2 locations. Consider refactoring.
Open

    ADD_INT:{ byte:0x90, instr:"add-int", ope: CONST.LEX.TOKEN.ADD, parse: MainParser.Format23x, type: CONST.INSTR_TYPE.MATH, reftype:ReferenceType.NONE, format:Format.Format23x, flag:Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER },
Severity: Major
Found in src/Opcode.js and 1 other location - About 1 hr to fix
src/Opcode.js on lines 904..904

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

Tuning

This issue has a mass of 92.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Further Reading

Similar blocks of code found in 2 locations. Consider refactoring.
Open

    NEG_INT:{ byte:0x7b, instr:"neg-int", ope: CONST.LEX.TOKEN.SUB, parse: MainParser.move, type: CONST.INSTR_TYPE.MATH, reftype:ReferenceType.NONE, format:Format.Format12x, flag:Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER },
Severity: Major
Found in src/Opcode.js and 1 other location - About 1 hr to fix
src/Opcode.js on lines 929..929

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

Tuning

This issue has a mass of 92.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Further Reading

Function sshow has 46 lines of code (exceeds 25 allowed). Consider refactoring.
Open

FinderResult.prototype.sshow = function(){
    let sub = [];
    this.data.map((k,x)=>{
        if(x instanceof CLASS.Method){
            sub.push({ 
Severity: Minor
Found in src/Finder.js - About 1 hr to fix

    Function updateDeviceList has 45 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

        updateDeviceList( pCandidateList){
            let active = 0, b=null, d=null, id=null, dev=null;
            let devs = {};
    
            for(let i=0; i<pCandidateList.length; i++){
    Severity: Minor
    Found in src/DeviceManager.js - About 1 hr to fix

      Function findCyclicRef has 45 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

      function findCyclicRef(obj,fullPath=[],endPath=[],cycle=0){
          let path = fullPath, end=endPath, k=0;
          if(cycle>cycleMax){
              //console.log("[E] Max cycle : "+path.join('.'));
              return false;
      Severity: Minor
      Found in src/BackupManager.js - About 1 hr to fix

        Function block has 45 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

        Disassembler.prototype.block = function(method,bb,nested,tagged){
            let before = " ".repeat((nested*2)+1);
            let ignore = [];
            //before += "╚═";
        
        
        Severity: Minor
        Found in src/Disassembler.js - About 1 hr to fix

          Function method has 45 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

          Disassembler.prototype.method = function(method){
          
                  let bb=null, txt="", prefix="";
                  
                  console.log("\n  "+method.signature());
          Severity: Minor
          Found in src/Disassembler.js - About 1 hr to fix

            Similar blocks of code found in 2 locations. Consider refactoring.
            Open

            Package.prototype.getAbsoluteSize = function(obj){
                let absz = 0;
                for(let i in this.children){
                    if(this.children[i] instanceof Class)
                        absz++;
            Severity: Major
            Found in src/CoreClass.js and 1 other location - About 1 hr to fix
            src/ModelPackage.js on lines 94..103

            Duplicated Code

            Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

            Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

            When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

            Tuning

            This issue has a mass of 91.

            We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

            The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

            If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

            See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

            Refactorings

            Further Reading

            Similar blocks of code found in 2 locations. Consider refactoring.
            Open

                getAbsoluteSize(){
                    let absz = 0;
                    for(let i in this.children){
                        if(this.children[i] instanceof Class)
                            absz++;
            Severity: Major
            Found in src/ModelPackage.js and 1 other location - About 1 hr to fix
            src/CoreClass.js on lines 390..399

            Duplicated Code

            Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

            Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

            When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

            Tuning

            This issue has a mass of 91.

            We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

            The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

            If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

            See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

            Refactorings

            Further Reading

            Identical blocks of code found in 2 locations. Consider refactoring.
            Open

                    for(let i in pattern){
                        res0 = res1;
                        res1 = [];
                        for(let meth in res0){
                            match = rx[i].exec(res0[meth][i]);
            Severity: Major
            Found in src/CoreClass.js and 1 other location - About 1 hr to fix
            src/CoreClass.js on lines 940..947

            Duplicated Code

            Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

            Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

            When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

            Tuning

            This issue has a mass of 91.

            We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

            The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

            If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

            See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

            Refactorings

            Further Reading

            Identical blocks of code found in 2 locations. Consider refactoring.
            Open

                for(let i in pattern){
                    res0 = res1;
                    res1 = [];
                    for(let meth in res0){
                        match = rx[i].exec(res0[meth][i]);
            Severity: Major
            Found in src/CoreClass.js and 1 other location - About 1 hr to fix
            src/CoreClass.js on lines 895..902

            Duplicated Code

            Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

            Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

            When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

            Tuning

            This issue has a mass of 91.

            We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

            The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

            If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

            See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

            Refactorings

            Further Reading

            Function scan has a Cognitive Complexity of 14 (exceeds 5 allowed). Consider refactoring.
            Open

                async scan(){
                    let dev=[], wrapper=null, activeDev = 0, latestDefault=null;
            
                    latestDefault = this.getDefault();
            
            
            Severity: Minor
            Found in src/DeviceManager.js - About 1 hr to fix

            Cognitive Complexity

            Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

            A method's cognitive complexity is based on a few simple rules:

            • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
            • Code is considered more complex for each "break in the linear flow of the code"
            • Code is considered more complex when "flow breaking structures are nested"

            Further reading

            Function fromJsonObject has a Cognitive Complexity of 14 (exceeds 5 allowed). Consider refactoring.
            Open

                static fromJsonObject( pJsonObject, pOverride = {}){
                    let dev = new Device();
                    for(let i in pJsonObject){
                        switch(i){
                            case 'type':
            Severity: Minor
            Found in src/Device.js - About 1 hr to fix

            Cognitive Complexity

            Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

            A method's cognitive complexity is based on a few simple rules:

            • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
            • Code is considered more complex for each "break in the linear flow of the code"
            • Code is considered more complex when "flow breaking structures are nested"

            Further reading

            Function fromString has a Cognitive Complexity of 14 (exceeds 5 allowed). Consider refactoring.
            Open

                static fromString( pType, pArrayStr){
                    const RE  = new RegExp('[\s\t]*\[[\s\t]*(?<ctn>.*)[\s\t]*\][\s\t]*');
                    let m = RE.exec(pArrayStr);
                    if(m == null){
                        throw new VM_Exception('VM002','Unable to parse bytearray parameter: invalid format');
            Severity: Minor
            Found in src/SmaliVM.js - About 1 hr to fix

            Cognitive Complexity

            Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

            A method's cognitive complexity is based on a few simple rules:

            • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
            • Code is considered more complex for each "break in the linear flow of the code"
            • Code is considered more complex when "flow breaking structures are nested"

            Further reading

            Similar blocks of code found in 42 locations. Consider refactoring.
            Open

                ADD_FLOAT:{ byte:0xa6, instr:"add-float", ope: CONST.LEX.TOKEN.ADD, parse: MainParser.Format23x, type: CONST.INSTR_TYPE.MATH, reftype: ReferenceType.NONE, format: Format.Format23x, flag:Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER },
            Severity: Major
            Found in src/Opcode.js and 41 other locations - About 1 hr to fix
            src/Opcode.js on lines 905..905
            src/Opcode.js on lines 908..908
            src/Opcode.js on lines 930..930
            src/Opcode.js on lines 931..931
            src/Opcode.js on lines 934..934
            src/Opcode.js on lines 935..935
            src/Opcode.js on lines 936..936
            src/Opcode.js on lines 937..937
            src/Opcode.js on lines 938..938
            src/Opcode.js on lines 939..939
            src/Opcode.js on lines 952..952
            src/Opcode.js on lines 953..953
            src/Opcode.js on lines 954..954
            src/Opcode.js on lines 955..955
            src/Opcode.js on lines 962..962
            src/Opcode.js on lines 963..963
            src/Opcode.js on lines 964..964
            src/Opcode.js on lines 967..967
            src/Opcode.js on lines 968..968
            src/Opcode.js on lines 969..969
            src/Opcode.js on lines 970..970
            src/Opcode.js on lines 971..971
            src/Opcode.js on lines 972..972
            src/Opcode.js on lines 984..984
            src/Opcode.js on lines 985..985
            src/Opcode.js on lines 986..986
            src/Opcode.js on lines 987..987
            src/Opcode.js on lines 988..988
            src/Opcode.js on lines 995..995
            src/Opcode.js on lines 997..997
            src/Opcode.js on lines 1000..1000
            src/Opcode.js on lines 1001..1001
            src/Opcode.js on lines 1002..1002
            src/Opcode.js on lines 1003..1003
            src/Opcode.js on lines 1005..1005
            src/Opcode.js on lines 1008..1008
            src/Opcode.js on lines 1009..1009
            src/Opcode.js on lines 1010..1010
            src/Opcode.js on lines 1011..1011
            src/Opcode.js on lines 1012..1012
            src/Opcode.js on lines 1013..1013

            Duplicated Code

            Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

            Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

            When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

            Tuning

            This issue has a mass of 90.

            We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

            The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

            If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

            See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

            Refactorings

            Further Reading

            Similar blocks of code found in 42 locations. Consider refactoring.
            Open

                XOR_INT:{ byte:0x97, instr:"xor-int", ope: CONST.LEX.TOKEN.XOR, parse: MainParser.Format23x, type: CONST.INSTR_TYPE.MATH, reftype: ReferenceType.NONE, format: Format.Format23x, flag:Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER },
            Severity: Major
            Found in src/Opcode.js and 41 other locations - About 1 hr to fix
            src/Opcode.js on lines 905..905
            src/Opcode.js on lines 908..908
            src/Opcode.js on lines 930..930
            src/Opcode.js on lines 931..931
            src/Opcode.js on lines 934..934
            src/Opcode.js on lines 935..935
            src/Opcode.js on lines 937..937
            src/Opcode.js on lines 938..938
            src/Opcode.js on lines 939..939
            src/Opcode.js on lines 951..951
            src/Opcode.js on lines 952..952
            src/Opcode.js on lines 953..953
            src/Opcode.js on lines 954..954
            src/Opcode.js on lines 955..955
            src/Opcode.js on lines 962..962
            src/Opcode.js on lines 963..963
            src/Opcode.js on lines 964..964
            src/Opcode.js on lines 967..967
            src/Opcode.js on lines 968..968
            src/Opcode.js on lines 969..969
            src/Opcode.js on lines 970..970
            src/Opcode.js on lines 971..971
            src/Opcode.js on lines 972..972
            src/Opcode.js on lines 984..984
            src/Opcode.js on lines 985..985
            src/Opcode.js on lines 986..986
            src/Opcode.js on lines 987..987
            src/Opcode.js on lines 988..988
            src/Opcode.js on lines 995..995
            src/Opcode.js on lines 997..997
            src/Opcode.js on lines 1000..1000
            src/Opcode.js on lines 1001..1001
            src/Opcode.js on lines 1002..1002
            src/Opcode.js on lines 1003..1003
            src/Opcode.js on lines 1005..1005
            src/Opcode.js on lines 1008..1008
            src/Opcode.js on lines 1009..1009
            src/Opcode.js on lines 1010..1010
            src/Opcode.js on lines 1011..1011
            src/Opcode.js on lines 1012..1012
            src/Opcode.js on lines 1013..1013

            Duplicated Code

            Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

            Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

            When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

            Tuning

            This issue has a mass of 90.

            We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

            The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

            If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

            See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

            Refactorings

            Further Reading

            Similar blocks of code found in 42 locations. Consider refactoring.
            Open

                SHR_INT:{ byte:0x99, instr:"shr-int", ope: CONST.LEX.TOKEN.SHR, parse: MainParser.Format23x, type: CONST.INSTR_TYPE.MATH, reftype: ReferenceType.NONE, format: Format.Format23x, flag:Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER },
            Severity: Major
            Found in src/Opcode.js and 41 other locations - About 1 hr to fix
            src/Opcode.js on lines 905..905
            src/Opcode.js on lines 908..908
            src/Opcode.js on lines 930..930
            src/Opcode.js on lines 931..931
            src/Opcode.js on lines 934..934
            src/Opcode.js on lines 935..935
            src/Opcode.js on lines 936..936
            src/Opcode.js on lines 937..937
            src/Opcode.js on lines 939..939
            src/Opcode.js on lines 951..951
            src/Opcode.js on lines 952..952
            src/Opcode.js on lines 953..953
            src/Opcode.js on lines 954..954
            src/Opcode.js on lines 955..955
            src/Opcode.js on lines 962..962
            src/Opcode.js on lines 963..963
            src/Opcode.js on lines 964..964
            src/Opcode.js on lines 967..967
            src/Opcode.js on lines 968..968
            src/Opcode.js on lines 969..969
            src/Opcode.js on lines 970..970
            src/Opcode.js on lines 971..971
            src/Opcode.js on lines 972..972
            src/Opcode.js on lines 984..984
            src/Opcode.js on lines 985..985
            src/Opcode.js on lines 986..986
            src/Opcode.js on lines 987..987
            src/Opcode.js on lines 988..988
            src/Opcode.js on lines 995..995
            src/Opcode.js on lines 997..997
            src/Opcode.js on lines 1000..1000
            src/Opcode.js on lines 1001..1001
            src/Opcode.js on lines 1002..1002
            src/Opcode.js on lines 1003..1003
            src/Opcode.js on lines 1005..1005
            src/Opcode.js on lines 1008..1008
            src/Opcode.js on lines 1009..1009
            src/Opcode.js on lines 1010..1010
            src/Opcode.js on lines 1011..1011
            src/Opcode.js on lines 1012..1012
            src/Opcode.js on lines 1013..1013

            Duplicated Code

            Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

            Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

            When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

            Tuning

            This issue has a mass of 90.

            We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

            The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

            If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

            See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

            Refactorings

            Further Reading

            Severity
            Category
            Status
            Source
            Language