tools/gyp/pylib/gyp/xcode_emulation.py

Summary

Maintainability
F
1 wk
Test Coverage

File xcode_emulation.py has 1097 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/xcode_emulation.py - About 2 days to fix

    XcodeSettings has 62 functions (exceeds 20 allowed). Consider refactoring.
    Open

    class XcodeSettings(object):
      """A class that understands the gyp 'xcode_settings' object."""
    
      # Populated lazily by _SdkPath(). Shared by all XcodeSettings, so cached
      # at class-level for efficiency.
    Severity: Major
    Found in tools/gyp/pylib/gyp/xcode_emulation.py - About 1 day to fix

      Function GetCflags has a Cognitive Complexity of 37 (exceeds 5 allowed). Consider refactoring.
      Open

        def GetCflags(self, configname, arch=None):
          """Returns flags that need to be added to .c, .cc, .m, and .mm
          compilations."""
          # This functions (and the similar ones below) do not offer complete
          # emulation of all xcode_settings keys. They're implemented on demand.
      Severity: Minor
      Found in tools/gyp/pylib/gyp/xcode_emulation.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 _GetXcodeEnv has a Cognitive Complexity of 17 (exceeds 5 allowed). Consider refactoring.
      Open

      def _GetXcodeEnv(xcode_settings, built_products_dir, srcroot, configuration,
                      additional_settings=None):
        """Return the environment variables that Xcode would set. See
        http://developer.apple.com/library/mac/#documentation/DeveloperTools/Reference/XcodeBuildSettingRef/1-Build_Setting_Reference/build_setting_ref.html#//apple_ref/doc/uid/TP40003931-CH3-SW153
        for a full list.
      Severity: Minor
      Found in tools/gyp/pylib/gyp/xcode_emulation.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 GetLdflags has a Cognitive Complexity of 14 (exceeds 5 allowed). Consider refactoring.
      Open

        def GetLdflags(self, configname, product_dir, gyp_to_build_path, arch=None):
          """Returns flags that need to be passed to the linker.
      
          Args:
              configname: The name of the configuration to get ld flags for.
      Severity: Minor
      Found in tools/gyp/pylib/gyp/xcode_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 GetExtraPlistItems has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring.
      Open

        def GetExtraPlistItems(self, configname=None):
          """Returns a dictionary with extra items to insert into Info.plist."""
          if configname not in XcodeSettings._plist_cache:
            cache = {}
            cache['BuildMachineOSBuild'] = self._BuildMachineOSBuild()
      Severity: Minor
      Found in tools/gyp/pylib/gyp/xcode_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 GetPerTargetSettings has a Cognitive Complexity of 12 (exceeds 5 allowed). Consider refactoring.
      Open

        def GetPerTargetSettings(self):
          """Gets a list of all the per-target settings. This will only fetch keys
          whose values are the same across all configurations."""
          first_pass = True
          result = {}
      Severity: Minor
      Found in tools/gyp/pylib/gyp/xcode_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 GetCflagsCC has a Cognitive Complexity of 12 (exceeds 5 allowed). Consider refactoring.
      Open

        def GetCflagsCC(self, configname):
          """Returns flags that need to be added to .cc, and .mm compilations."""
          self.configname = configname
          cflags_cc = []
      
      
      Severity: Minor
      Found in tools/gyp/pylib/gyp/xcode_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 _XcodeVersion has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.
      Open

        def _XcodeVersion(self):
          # `xcodebuild -version` output looks like
          #    Xcode 4.6.3
          #    Build version 4H1503
          # or like
      Severity: Minor
      Found in tools/gyp/pylib/gyp/xcode_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, configname, arch=None):
          """Returns flags that need to be added to .c, .cc, .m, and .mm
          compilations."""
          # This functions (and the similar ones below) do not offer complete
          # emulation of all xcode_settings keys. They're implemented on demand.
      Severity: Minor
      Found in tools/gyp/pylib/gyp/xcode_emulation.py - About 1 hr to fix

        Function _DefaultSdkRoot has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.
        Open

          def _DefaultSdkRoot(self):
            """Returns the default SDKROOT to use.
        
            Prior to version 5.0.0, if SDKROOT was not explicitly set in the Xcode
            project, then the environment variable was empty. Starting with this
        Severity: Minor
        Found in tools/gyp/pylib/gyp/xcode_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 _GetStripPostbuilds has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.
        Open

          def _GetStripPostbuilds(self, configname, output_binary, quiet):
            """Returns a list of shell commands that contain the shell commands
            neccessary to strip this target's binary. These should be run as postbuilds
            before the actual postbuilds run."""
            self.configname = configname
        Severity: Minor
        Found in tools/gyp/pylib/gyp/xcode_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 _GetIOSCodeSignIdentityKey has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.
        Open

          def _GetIOSCodeSignIdentityKey(self, settings):
            identity = settings.get('CODE_SIGN_IDENTITY')
            if not identity:
              return None
            if identity not in XcodeSettings._codesigning_key_cache:
        Severity: Minor
        Found in tools/gyp/pylib/gyp/xcode_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 AddImplicitPostbuilds has 5 arguments (exceeds 4 allowed). Consider refactoring.
        Open

          def AddImplicitPostbuilds(self, configname, output, output_binary,
        Severity: Minor
        Found in tools/gyp/pylib/gyp/xcode_emulation.py - About 35 mins to fix

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

          def _GetXcodeEnv(xcode_settings, built_products_dir, srcroot, configuration,
          Severity: Minor
          Found in tools/gyp/pylib/gyp/xcode_emulation.py - About 35 mins to fix

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

            def GetSortedXcodeEnv(xcode_settings, built_products_dir, srcroot,
            Severity: Minor
            Found in tools/gyp/pylib/gyp/xcode_emulation.py - About 35 mins to fix

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

              def GetMacBundleResources(product_dir, xcode_settings, resources):
                """Yields (output, resource) pairs for every resource in |resources|.
                Only call this for mac bundle targets.
              
                Args:
              Severity: Minor
              Found in tools/gyp/pylib/gyp/xcode_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

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

                def _ConvertConditionalKeys(self, configname):
                  """Converts or warns on conditional keys.  Xcode supports conditional keys,
                  such as CODE_SIGN_IDENTITY[sdk=iphoneos*].  This is a partial implementation
                  with some keys converted while the rest force a warning."""
                  settings = self.xcode_settings[configname]
              Severity: Minor
              Found in tools/gyp/pylib/gyp/xcode_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

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

                def __init__(self, xcode_settings,
                             gyp_path_to_build_path, gyp_path_to_build_output):
                  """If xcode_settings is None, all methods on this class are no-ops.
              
                  Args:
              Severity: Minor
              Found in tools/gyp/pylib/gyp/xcode_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

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

                def GetInstallName(self):
                  """Return LD_DYLIB_INSTALL_NAME for this target."""
                  # Xcode sets this for shared_libraries, and for nonbundled loadable_modules.
                  if (self.spec['type'] != 'shared_library' and
                      (self.spec['type'] != 'loadable_module' or self._IsBundle())):
              Severity: Minor
              Found in tools/gyp/pylib/gyp/xcode_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

              Avoid too many return statements within this function.
              Open

                  return ''
              Severity: Major
              Found in tools/gyp/pylib/gyp/xcode_emulation.py - About 30 mins to fix

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

                def _HasIOSTarget(targets):
                  """Returns true if any target contains the iOS specific key
                  IPHONEOS_DEPLOYMENT_TARGET."""
                  for target_dict in targets.values():
                    for config in target_dict['configurations'].values():
                Severity: Minor
                Found in tools/gyp/pylib/gyp/xcode_emulation.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 _AdjustLibrary has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
                Open

                  def _AdjustLibrary(self, library, config_name=None):
                    if library.endswith('.framework'):
                      l = '-framework ' + os.path.splitext(os.path.basename(library))[0]
                    else:
                      m = self.library_re.match(library)
                Severity: Minor
                Found in tools/gyp/pylib/gyp/xcode_emulation.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 _GetStandaloneBinaryPath has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
                Open

                  def _GetStandaloneBinaryPath(self):
                    """Returns the name of the non-bundle binary represented by this target.
                    E.g. hello_world. Only valid for non-bundles."""
                    assert not self._IsBundle()
                    assert self.spec['type'] in (
                Severity: Minor
                Found in tools/gyp/pylib/gyp/xcode_emulation.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 _AddIOSDeviceConfigurations has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
                Open

                def _AddIOSDeviceConfigurations(targets):
                  """Clone all targets and append -iphoneos to the name. Configure these targets
                  to build for iOS devices."""
                  for target_dict in targets.values():
                    for config_name in target_dict['configurations'].keys():
                Severity: Minor
                Found in tools/gyp/pylib/gyp/xcode_emulation.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

                    if (self.spec['type'] != 'shared_library' and
                        (self.spec['type'] != 'loadable_module' or self._IsBundle())):
                      return None
                Severity: Major
                Found in tools/gyp/pylib/gyp/xcode_emulation.py and 1 other location - About 1 hr to fix
                tools/gyp/pylib/gyp/xcode_emulation.py on lines 525..527

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

                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

                    if (self.spec['type'] != 'shared_library' and
                        (self.spec['type'] != 'loadable_module' or self._IsBundle())):
                      return None
                Severity: Major
                Found in tools/gyp/pylib/gyp/xcode_emulation.py and 1 other location - About 1 hr to fix
                tools/gyp/pylib/gyp/xcode_emulation.py on lines 548..550

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

                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

                    if arch is not None:
                      archs = [arch]
                    else:
                      archs = self._Settings().get('ARCHS', [self._DefaultArch()])
                Severity: Major
                Found in tools/gyp/pylib/gyp/xcode_emulation.py and 1 other location - About 1 hr to fix
                tools/gyp/pylib/gyp/xcode_emulation.py on lines 653..656

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

                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

                    if arch is not None:
                      archs = [arch]
                    else:
                      archs = self._Settings().get('ARCHS', [self._DefaultArch()])
                Severity: Major
                Found in tools/gyp/pylib/gyp/xcode_emulation.py and 1 other location - About 1 hr to fix
                tools/gyp/pylib/gyp/xcode_emulation.py on lines 396..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 40.

                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

                    if output.endswith('.xib'):
                      output = os.path.splitext(output)[0] + '.nib'
                Severity: Minor
                Found in tools/gyp/pylib/gyp/xcode_emulation.py and 1 other location - About 45 mins to fix
                tools/gyp/pylib/gyp/xcode_emulation.py on lines 1198..1199

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

                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

                    if output.endswith('.storyboard'):
                      output = os.path.splitext(output)[0] + '.storyboardc'
                Severity: Minor
                Found in tools/gyp/pylib/gyp/xcode_emulation.py and 1 other location - About 45 mins to fix
                tools/gyp/pylib/gyp/xcode_emulation.py on lines 1195..1196

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

                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 GetExecutablePath(self):
                    """Returns the directory name of the bundle represented by this target. E.g.
                    Chromium.app/Contents/MacOS/Chromium."""
                    if self._IsBundle():
                      return self._GetBundleBinaryPath()
                Severity: Minor
                Found in tools/gyp/pylib/gyp/xcode_emulation.py and 1 other location - About 30 mins to fix
                tools/gyp/pylib/gyp/xcode_emulation.py on lines 130..135

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

                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 GetFullProductName(self):
                    """Returns FULL_PRODUCT_NAME."""
                    if self._IsBundle():
                      return self.GetWrapperName()
                    else:
                Severity: Minor
                Found in tools/gyp/pylib/gyp/xcode_emulation.py and 1 other location - About 30 mins to fix
                tools/gyp/pylib/gyp/xcode_emulation.py on lines 260..266

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

                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