Sign upLogin

joyent/node

View on GitHub
Star
tools/gyp/pylib/gyp/msvs_emulation.py

Summary

Maintainability
F
5 days
Test Coverage

File msvs_emulation.py has 764 lines of code (exceeds 250 allowed). Consider refactoring.
Open

# Copyright (c) 2012 Google Inc. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

"""
Severity: Major
Found in tools/gyp/pylib/gyp/msvs_emulation.py - About 1 day to fix

    MsvsSettings has 38 functions (exceeds 20 allowed). Consider refactoring.
    Open

    class MsvsSettings(object):
  """A class that understands the gyp 'msvs_...' values (especially the
  msvs_settings field). They largely correpond to the VS2008 IDE DOM. This
  class helps map those settings to command line options."""
    Severity: Minor
    Found in tools/gyp/pylib/gyp/msvs_emulation.py - About 5 hrs to fix

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

        def GetLdflags(self, config, gyp_to_build_path, expand_special,
                 manifest_base_name, output_name, is_executable, build_dir):
    """Returns the flags that need to be added to link commands, and the
    manifest files."""
    config = self._TargetConfig(config)
      Severity: Minor
      Found in tools/gyp/pylib/gyp/msvs_emulation.py - About 1 hr to fix

        Function _ExtractImportantEnvironment has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring.
        Open

        def _ExtractImportantEnvironment(output_of_set):
  """Extracts environment variables required for the toolchain to run from
  a textual dump output by the cmd.exe 'set' command."""
  envvars_to_save = (
      'goma_.*', # TODO(scottmg): This is ugly, but needed for goma.
        Severity: Minor
        Found in tools/gyp/pylib/gyp/msvs_emulation.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 GetCflags has 31 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

          def GetCflags(self, config):
    """Returns the flags that need to be added to .c and .cc compilations."""
    config = self._TargetConfig(config)
    cflags = []
    cflags.extend(['/wd' + w for w in self.msvs_disabled_warnings[config]])
        Severity: Minor
        Found in tools/gyp/pylib/gyp/msvs_emulation.py - About 1 hr to fix

          Function GetLdflags has 8 arguments (exceeds 4 allowed). Consider refactoring.
          Open

            def GetLdflags(self, config, gyp_to_build_path, expand_special,
          Severity: Major
          Found in tools/gyp/pylib/gyp/msvs_emulation.py - About 1 hr to fix

            Function GetLdflags has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.
            Open

              def GetLdflags(self, config, gyp_to_build_path, expand_special,
                 manifest_base_name, output_name, is_executable, build_dir):
    """Returns the flags that need to be added to link commands, and the
    manifest files."""
    config = self._TargetConfig(config)
            Severity: Minor
            Found in tools/gyp/pylib/gyp/msvs_emulation.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 _Setting has 7 arguments (exceeds 4 allowed). Consider refactoring.
            Open

              def _Setting(self, path, config,
            Severity: Major
            Found in tools/gyp/pylib/gyp/msvs_emulation.py - About 50 mins to fix

              Function _ConfigAttrib has 7 arguments (exceeds 4 allowed). Consider refactoring.
              Open

                def _ConfigAttrib(self, path, config,
              Severity: Major
              Found in tools/gyp/pylib/gyp/msvs_emulation.py - About 50 mins to fix

                Function GetFlagsModifications has 7 arguments (exceeds 4 allowed). Consider refactoring.
                Open

                  def GetFlagsModifications(self, input, output, implicit, command,
                Severity: Major
                Found in tools/gyp/pylib/gyp/msvs_emulation.py - About 50 mins to fix

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

                    def _GetLdManifestFlags(self, config, name, gyp_to_build_path,
                  Severity: Minor
                  Found in tools/gyp/pylib/gyp/msvs_emulation.py - About 45 mins to fix

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

                    def _DoRemapping(element, map):
  """If |element| then remap it through |map|. If |element| is iterable then
  each item will be remapped. Any elements not found will be removed."""
  if map is not None and element is not None:
    if not callable(map):
                    Severity: Minor
                    Found in tools/gyp/pylib/gyp/msvs_emulation.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 _FindDirectXInstallation has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.
                    Open

                    def _FindDirectXInstallation():
  """Try to find an installation location for the DirectX SDK. Check for the
  standard environment variable, and if that doesn't exist, try to find
  via the registry. May return None if not found in either location."""
  # Return previously calculated value, if there is one
                    Severity: Minor
                    Found in tools/gyp/pylib/gyp/msvs_emulation.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 _GetAndMunge has 6 arguments (exceeds 4 allowed). Consider refactoring.
                    Open

                      def _GetAndMunge(self, field, path, default, prefix, append, map):
                    Severity: Minor
                    Found in tools/gyp/pylib/gyp/msvs_emulation.py - About 45 mins to fix

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

                        def __init__(
                      Severity: Minor
                      Found in tools/gyp/pylib/gyp/msvs_emulation.py - About 35 mins to fix

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

                        def _AppendOrReturn(append, element):
  """If |append| is None, simply return |element|. If |append| is not None,
  then add |element| to it, adding each item in |element| if it's a list or
  tuple."""
  if append is not None and element is not None:
                        Severity: Minor
                        Found in tools/gyp/pylib/gyp/msvs_emulation.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

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

                          def GetMapFileName(self, config, expand_special):
    """Gets the explicitly overriden map file name for a target or returns None
    if it's not set."""
    config = self._TargetConfig(config)
    map_file = self._Setting(('VCLinkerTool', 'MapFileName'), config)
                        Severity: Major
                        Found in tools/gyp/pylib/gyp/msvs_emulation.py and 1 other location - About 3 hrs to fix
                        tools/gyp/pylib/gyp/msvs_emulation.py on lines 450..459

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

                        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

                          def GetPGDName(self, config, expand_special):
    """Gets the explicitly overridden pgd name for a target or returns None
    if it's not overridden."""
    config = self._TargetConfig(config)
    output_file = self._Setting(
                        Severity: Major
                        Found in tools/gyp/pylib/gyp/msvs_emulation.py and 1 other location - About 3 hrs to fix
                        tools/gyp/pylib/gyp/msvs_emulation.py on lines 298..305

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

                        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

                          def _ConfigAttrib(self, path, config,
                   default=None, prefix='', append=None, map=None):
    """_GetAndMunge for msvs_configuration_attributes."""
    return self._GetAndMunge(
        self.msvs_configuration_attributes[config],
                        Severity: Major
                        Found in tools/gyp/pylib/gyp/msvs_emulation.py and 1 other location - About 1 hr to fix
                        tools/gyp/pylib/gyp/msvs_emulation.py on lines 253..257

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

                        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

                          def _Setting(self, path, config,
              default=None, prefix='', append=None, map=None):
    """_GetAndMunge for msvs_settings."""
    return self._GetAndMunge(
        self.msvs_settings[config], path, default, prefix, append, map)
                        Severity: Major
                        Found in tools/gyp/pylib/gyp/msvs_emulation.py and 1 other location - About 1 hr to fix
                        tools/gyp/pylib/gyp/msvs_emulation.py on lines 259..264

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

                        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