Sign upLogin

conan-io/conan

View on GitHub
Star

Showing 364 of 2,550 total issues

Function print_graph has a Cognitive Complexity of 25 (exceeds 20 allowed). Consider refactoring.
Open

def print_graph(deps_graph, out):
    requires = OrderedDict()
    build_requires = OrderedDict()
    python_requires = set()
    build_time_nodes = deps_graph.build_time_nodes()
Severity: Minor
Found in conans/client/graph/printer.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 loads has a Cognitive Complexity of 25 (exceeds 20 allowed). Consider refactoring.
Open

    def loads(text):
        result = ProfileEnvironment()
        for line in text.splitlines():
            line = line.strip()
            if not line or line.startswith("#"):
Severity: Minor
Found in conan/tools/env/environment.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 14 arguments (exceeds 10 allowed). Consider refactoring.
Open

    def test(self, path, reference, profile_names=None, settings=None, options=None, env=None,
Severity: Major
Found in conans/client/conan_api.py - About 1 hr to fix

    Function lock_create has 14 arguments (exceeds 10 allowed). Consider refactoring.
    Open

        def lock_create(self, path, lockfile_out,
    Severity: Major
    Found in conans/client/conan_api.py - About 1 hr to fix

      Function get_command has 14 arguments (exceeds 10 allowed). Consider refactoring.
      Open

          def get_command(self, project_file, props_file_path=None, targets=None, upgrade_project=True,
      Severity: Major
      Found in conans/client/build/msbuild.py - About 1 hr to fix

        Function install_build_and_test has 14 arguments (exceeds 10 allowed). Consider refactoring.
        Open

        def install_build_and_test(app, conanfile_abs_path, reference, graph_info,
        Severity: Major
        Found in conans/client/cmd/test.py - About 1 hr to fix

          Function cmd_export has a Cognitive Complexity of 24 (exceeds 20 allowed). Consider refactoring.
          Open

          def cmd_export(app, conanfile_path, name, version, user, channel, keep_source,
               export=True, graph_lock=None, ignore_dirty=False):
    """ Export the recipe
    param conanfile_path: the original source directory of the user containing a
                       conanfile.py
          Severity: Minor
          Found in conans/client/cmd/export.py - About 55 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 __cmp__ has a Cognitive Complexity of 24 (exceeds 20 allowed). Consider refactoring.
          Open

              def __cmp__(self, other):
        if other is None:
            return 1
        if not isinstance(other, Version):
            other = Version(other)
          Severity: Minor
          Found in conans/model/version.py - About 55 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 create has a Cognitive Complexity of 24 (exceeds 20 allowed). Consider refactoring.
          Open

              def create(lockfiles, revisions_enabled, cwd):
        def ref_convert(r):
            # Necessary so "build-order" output is usable by install
            if "@" not in r:
                if "#" in r:
          Severity: Minor
          Found in conans/model/lock_bundle.py - About 55 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 download has 13 arguments (exceeds 10 allowed). Consider refactoring.
          Open

          def download(url, filename, verify=True, out=None, retry=None, retry_wait=None, overwrite=False,
          Severity: Major
          Found in conans/client/tools/net.py - About 50 mins to fix

            Function _expand_require has 13 arguments (exceeds 10 allowed). Consider refactoring.
            Open

                def _expand_require(self, require, node, graph, check_updates, update, remotes, profile_host,
            Severity: Major
            Found in conans/client/graph/graph_builder.py - About 50 mins to fix

              Function upload has 12 arguments (exceeds 10 allowed). Consider refactoring.
              Open

                  def upload(self, reference_or_pattern, remotes, upload_recorder, package_id=None,
              Severity: Major
              Found in conans/client/cmd/uploader.py - About 45 mins to fix

                Function _process_file has a Cognitive Complexity of 23 (exceeds 20 allowed). Consider refactoring.
                Open

                def _process_file(directory, filename, config, cache, output, folder):
    if filename == "settings.yml":
        output.info("Installing settings.yml")
        _filecopy(directory, filename, cache.cache_folder)
    elif filename == "conan.conf":
                Severity: Minor
                Found in conans/client/conf/config_installer.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 search has a Cognitive Complexity of 23 (exceeds 20 allowed). Consider refactoring.
                Open

                    def search(self, *args):
        """
        Searches package recipes and binaries in the local cache or a remote.
        Unless a remote is specified only the local cache is searched.
                Severity: Minor
                Found in conans/client/command.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

                Avoid deeply nested control flow statements.
                Open

                                        if start:
                            break
                        start = True
                Severity: Major
                Found in conans/client/command.py - About 45 mins to fix

                  Avoid deeply nested control flow statements.
                  Open

                                          if pkg_metadata.remote == remote_name:
                            pkg_metadata.remote = None
                  Severity: Major
                  Found in conans/client/cache/remote_registry.py - About 45 mins to fix

                    Avoid deeply nested control flow statements.
                    Open

                                            if isinstance(src_dirs, list):  # it can return a "config" CppInfo item!
                            src_dirs += src_dir
                    Severity: Major
                    Found in conans/client/importer.py - About 45 mins to fix

                      Function __init__ has 12 arguments (exceeds 10 allowed). Consider refactoring.
                      Open

                          def __init__(self, conanfile, generator=None, cmake_system_name=True,
                      Severity: Major
                      Found in conans/client/build/cmake.py - About 45 mins to fix

                        Function export_pkg has 12 arguments (exceeds 10 allowed). Consider refactoring.
                        Open

                        def export_pkg(app, recorder, full_ref, source_folder, build_folder, package_folder, install_folder,
                        Severity: Major
                        Found in conans/client/cmd/export_pkg.py - About 45 mins to fix

                          Avoid deeply nested control flow statements.
                          Open

                                                  if metadata.recipe.remote == renamed:
                            metadata.recipe.remote = remote_name
                        for pkg_metadata in metadata.packages.values():
                          Severity: Major
                          Found in conans/client/cache/remote_registry.py - About 45 mins to fix
                            Severity
                            Category
                            Status
                            Source
                            Language