Sign upLogin

hackedteam/vector-edk

View on GitHub
Star
vector-uefi/fd/efi/StdLib/lib/python.27/urllib.py

Summary

Maintainability
F
4 mos
Test Coverage

File urllib.py has 1347 lines of code (exceeds 250 allowed). Consider refactoring.
Open

"""Open an arbitrary URL.

See the following document for more info on URLs:
"Names and Addresses, URIs, URLs, URNs, URCs", at
http://www.w3.org/pub/WWW/Addressing/Overview.html
Severity: Major
Found in vector-uefi/fd/efi/StdLib/lib/python.27/urllib.py - About 3 days to fix

    Function open_https has a Cognitive Complexity of 49 (exceeds 5 allowed). Consider refactoring.
    Open

            def open_https(self, url, data=None):
            """Use HTTPS protocol."""

            import httplib
            user_passwd = None
    Severity: Minor
    Found in vector-uefi/fd/efi/StdLib/lib/python.27/urllib.py - About 7 hrs 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 proxy_bypass_macosx_sysconf has a Cognitive Complexity of 35 (exceeds 5 allowed). Consider refactoring.
    Open

        def proxy_bypass_macosx_sysconf(host):
        """
        Return True iff this host shouldn't be accessed using a proxy

        This function uses the MacOSX framework SystemConfiguration
    Severity: Minor
    Found in vector-uefi/fd/efi/StdLib/lib/python.27/urllib.py - About 5 hrs 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 open_http has a Cognitive Complexity of 35 (exceeds 5 allowed). Consider refactoring.
    Open

        def open_http(self, url, data=None):
        """Use HTTP protocol."""
        import httplib
        user_passwd = None
        proxy_passwd= None
    Severity: Minor
    Found in vector-uefi/fd/efi/StdLib/lib/python.27/urllib.py - About 5 hrs 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 proxy_bypass_registry has a Cognitive Complexity of 30 (exceeds 5 allowed). Consider refactoring.
    Open

        def proxy_bypass_registry(host):
        try:
            import _winreg
            import re
        except ImportError:
    Severity: Minor
    Found in vector-uefi/fd/efi/StdLib/lib/python.27/urllib.py - About 4 hrs 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 open_ftp has a Cognitive Complexity of 26 (exceeds 5 allowed). Consider refactoring.
    Open

        def open_ftp(self, url):
        """Use FTP protocol."""
        if not isinstance(url, str):
            raise IOError, ('ftp error', 'proxy support for ftp protocol currently not implemented')
        import mimetypes, mimetools
    Severity: Minor
    Found in vector-uefi/fd/efi/StdLib/lib/python.27/urllib.py - About 3 hrs 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 urlencode has a Cognitive Complexity of 26 (exceeds 5 allowed). Consider refactoring.
    Open

    def urlencode(query, doseq=0):
    """Encode a sequence of two-element tuples or dictionary into a URL query string.

    If any values in the query arg are sequences and doseq is true, each
    sequence element is converted to a separate parameter.
    Severity: Minor
    Found in vector-uefi/fd/efi/StdLib/lib/python.27/urllib.py - About 3 hrs 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 getproxies_registry has a Cognitive Complexity of 24 (exceeds 5 allowed). Consider refactoring.
    Open

        def getproxies_registry():
        """Return a dictionary of scheme -> proxy server URL mappings.

        Win32 uses the registry to store proxies.
    Severity: Minor
    Found in vector-uefi/fd/efi/StdLib/lib/python.27/urllib.py - About 3 hrs 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 retrieve has a Cognitive Complexity of 18 (exceeds 5 allowed). Consider refactoring.
    Open

        def retrieve(self, url, filename=None, reporthook=None, data=None):
        """retrieve(url) returns (filename, headers) for a local object
        or (tempfilename, headers) for a remote object."""
        url = unwrap(toBytes(url))
        if self.tempcache and url in self.tempcache:
    Severity: Minor
    Found in vector-uefi/fd/efi/StdLib/lib/python.27/urllib.py - About 2 hrs 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 retrfile has a Cognitive Complexity of 17 (exceeds 5 allowed). Consider refactoring.
    Open

        def retrfile(self, file, type):
        import ftplib
        self.endtransfer()
        if type in ('d', 'D'): cmd = 'TYPE A'; isdir = 1
        else: cmd = 'TYPE ' + type; isdir = 0
    Severity: Minor
    Found in vector-uefi/fd/efi/StdLib/lib/python.27/urllib.py - About 2 hrs 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 main has a Cognitive Complexity of 14 (exceeds 5 allowed). Consider refactoring.
    Open

    def main():
    import getopt, sys
    try:
        opts, args = getopt.getopt(sys.argv[1:], "th")
    except getopt.error, msg:
    Severity: Minor
    Found in vector-uefi/fd/efi/StdLib/lib/python.27/urllib.py - 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 open has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring.
    Open

        def open(self, fullurl, data=None):
        """Use URLopener().open(file) instead of open(file, 'r')."""
        fullurl = unwrap(toBytes(fullurl))
        # percent encode url, fixing lame server errors for e.g, like space
        # within url paths.
    Severity: Minor
    Found in vector-uefi/fd/efi/StdLib/lib/python.27/urllib.py - 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 test has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.
    Open

    def test(args=[]):
    if not args:
        args = [
            '/etc/passwd',
            'file:/etc/passwd',
    Severity: Minor
    Found in vector-uefi/fd/efi/StdLib/lib/python.27/urllib.py - 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 open_local_file has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.
    Open

        def open_local_file(self, url):
        """Use local file."""
        import mimetypes, mimetools, email.utils
        try:
            from cStringIO import StringIO
    Severity: Minor
    Found in vector-uefi/fd/efi/StdLib/lib/python.27/urllib.py - 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 http_error_302 has 6 arguments (exceeds 4 allowed). Consider refactoring.
    Open

        def http_error_302(self, url, fp, errcode, errmsg, headers, data=None):
    Severity: Minor
    Found in vector-uefi/fd/efi/StdLib/lib/python.27/urllib.py - About 45 mins to fix

      Function http_error_401 has 6 arguments (exceeds 4 allowed). Consider refactoring.
      Open

          def http_error_401(self, url, fp, errcode, errmsg, headers, data=None):
      Severity: Minor
      Found in vector-uefi/fd/efi/StdLib/lib/python.27/urllib.py - About 45 mins to fix

        Function http_error_407 has 6 arguments (exceeds 4 allowed). Consider refactoring.
        Open

            def http_error_407(self, url, fp, errcode, errmsg, headers, data=None):
        Severity: Minor
        Found in vector-uefi/fd/efi/StdLib/lib/python.27/urllib.py - About 45 mins to fix

          Function __init__ has 6 arguments (exceeds 4 allowed). Consider refactoring.
          Open

              def __init__(self, user, passwd, host, port, dirs,
          Severity: Minor
          Found in vector-uefi/fd/efi/StdLib/lib/python.27/urllib.py - About 45 mins to fix

            Function http_error_307 has 6 arguments (exceeds 4 allowed). Consider refactoring.
            Open

                def http_error_307(self, url, fp, errcode, errmsg, headers, data=None):
            Severity: Minor
            Found in vector-uefi/fd/efi/StdLib/lib/python.27/urllib.py - About 45 mins to fix

              Function redirect_internal has 6 arguments (exceeds 4 allowed). Consider refactoring.
              Open

                  def redirect_internal(self, url, fp, errcode, errmsg, headers, data):
              Severity: Minor
              Found in vector-uefi/fd/efi/StdLib/lib/python.27/urllib.py - About 45 mins to fix

                Avoid deeply nested control flow statements.
                Open

                                        if not re.match('^([^/:]+)://', address):
                            address = '%s://%s' % (protocol, address)
                        proxies[protocol] = address
                Severity: Major
                Found in vector-uefi/fd/efi/StdLib/lib/python.27/urllib.py - About 45 mins to fix

                  Function http_error_303 has 6 arguments (exceeds 4 allowed). Consider refactoring.
                  Open

                      def http_error_303(self, url, fp, errcode, errmsg, headers, data=None):
                  Severity: Minor
                  Found in vector-uefi/fd/efi/StdLib/lib/python.27/urllib.py - About 45 mins to fix

                    Function http_error has 6 arguments (exceeds 4 allowed). Consider refactoring.
                    Open

                        def http_error(self, url, fp, errcode, errmsg, headers, data=None):
                    Severity: Minor
                    Found in vector-uefi/fd/efi/StdLib/lib/python.27/urllib.py - About 45 mins to fix

                      Function http_error_301 has 6 arguments (exceeds 4 allowed). Consider refactoring.
                      Open

                          def http_error_301(self, url, fp, errcode, errmsg, headers, data=None):
                      Severity: Minor
                      Found in vector-uefi/fd/efi/StdLib/lib/python.27/urllib.py - About 45 mins to fix

                        Function open_data has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.
                        Open

                            def open_data(self, url, data=None):
        """Use "data" URL."""
        if not isinstance(url, str):
            raise IOError, ('data error', 'proxy support for data protocol currently not implemented')
        # ignore POSTed data
                        Severity: Minor
                        Found in vector-uefi/fd/efi/StdLib/lib/python.27/urllib.py - About 45 mins 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 http_error_default has 5 arguments (exceeds 4 allowed). Consider refactoring.
                        Open

                            def http_error_default(self, url, fp, errcode, errmsg, headers):
                        Severity: Minor
                        Found in vector-uefi/fd/efi/StdLib/lib/python.27/urllib.py - About 35 mins to fix

                          Function http_error_default has 5 arguments (exceeds 4 allowed). Consider refactoring.
                          Open

                              def http_error_default(self, url, fp, errcode, errmsg, headers):
                          Severity: Minor
                          Found in vector-uefi/fd/efi/StdLib/lib/python.27/urllib.py - About 35 mins to fix

                            Function cleanup has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.
                            Open

                                def cleanup(self):
        # This code sometimes runs when the rest of this module
        # has already been deleted, so it can't use any globals
        # or import anything.
        if self.__tempfiles:
                            Severity: Minor
                            Found in vector-uefi/fd/efi/StdLib/lib/python.27/urllib.py - About 35 mins 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 proxy_bypass_environment has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.
                            Open

                            def proxy_bypass_environment(host):
    """Test if proxies should not be used for a particular host.

    Checks the environment for a variable named no_proxy, which should
    be a list of DNS suffixes separated by commas, or '*' for all hosts.
                            Severity: Minor
                            Found in vector-uefi/fd/efi/StdLib/lib/python.27/urllib.py - About 35 mins 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

                            Avoid too many return statements within this function.
                            Open

                                    return 0
                            Severity: Major
                            Found in vector-uefi/fd/efi/StdLib/lib/python.27/urllib.py - About 30 mins to fix

                              Avoid too many return statements within this function.
                              Open

                                              return getattr(self, name)(url, data)
                              Severity: Major
                              Found in vector-uefi/fd/efi/StdLib/lib/python.27/urllib.py - About 30 mins to fix

                                Avoid too many return statements within this function.
                                Open

                                                    return 1
                                Severity: Major
                                Found in vector-uefi/fd/efi/StdLib/lib/python.27/urllib.py - About 30 mins to fix

                                  Function splitnport has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
                                  Open

                                  def splitnport(host, defport=-1):
    """Split host and port, returning numeric port.
    Return given default port if no ':' found; defaults to -1.
    Return numerical port if a valid number are found after ':'.
    Return None if ':' but not a valid number."""
                                  Severity: Minor
                                  Found in vector-uefi/fd/efi/StdLib/lib/python.27/urllib.py - About 25 mins 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 __init__ has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
                                  Open

                                      def __init__(self, fp):
        self.fp = fp
        self.read = self.fp.read
        self.readline = self.fp.readline
        if hasattr(self.fp, "readlines"): self.readlines = self.fp.readlines
                                  Severity: Minor
                                  Found in vector-uefi/fd/efi/StdLib/lib/python.27/urllib.py - About 25 mins 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 http_error has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
                                  Open

                                      def http_error(self, url, fp, errcode, errmsg, headers, data=None):
        """Handle http errors.
        Derived class can override this, or provide specific handlers
        named http_error_DDD where DDD is the 3-digit error code."""
        # First check if there's a specific handler for this error
                                  Severity: Minor
                                  Found in vector-uefi/fd/efi/StdLib/lib/python.27/urllib.py - About 25 mins 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 unquote has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
                                  Open

                                  def unquote(s):
    """unquote('abc%20def') -> 'abc def'."""
    res = s.split('%')
    # fastpath
    if len(res) == 1:
                                  Severity: Minor
                                  Found in vector-uefi/fd/efi/StdLib/lib/python.27/urllib.py - About 25 mins 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

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

                                  Severity: Major
                                  Found in vector-uefi/fd/efi/StdLib/lib/python.27/urllib.py and 1 other location - About 4 mos to fix
                                  AppPkg/Applications/Python/Python-2.7.2/Lib/urllib.py on lines 0..1646

                                  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 10983.

                                  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

                                  There are no issues that match your filters.

                                  Category
                                  Status