Cleanup pylint errors

pylib/gyp/generator/ninja.py

 # Copyright (c) 2013 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.
 
 import collections
 import copy
 import hashlib
 import json
 import multiprocessing
 import os.path
@@ skipping 90 matching lines @@
     d = d.replace('#', '\\%03o' % ord('#'))
   return QuoteShellArgument(ninja_syntax.escape('-D' + d), flavor)
 
 
 def AddArch(output, arch):
   """Adds an arch string to an output path."""
   output, extension = os.path.splitext(output)
   return '%s.%s%s' % (output, arch, extension)
 
 
-class Target:
+class Target(object):
   """Target represents the paths used within a single gyp target.
 
   Conceptually, building a single target A is a series of steps:
 
   1) actions/rules/copies  generates source/resources/etc.
   2) compiles              generates .o files
   3) link                  generates a binary (library/executable)
   4) bundle                merges the above in a mac bundle
 
   (Any of these steps can be optional.)
@@ skipping 83 matching lines @@
 # We translate between these two notions of paths with two helper
 # functions:
 #
 # - GypPathToNinja translates a gyp path (i.e. relative to the .gyp file)
 #   into the equivalent ninja path.
 #
 # - GypPathToUniqueOutput translates a gyp path into a ninja path to write
 #   an output file; the result can be namespaced such that it is unique
 #   to the input file name as well as the output target name.
 
-class NinjaWriter:
+class NinjaWriter(object):
   def __init__(self, hash_for_rules, target_outputs, base_dir, build_dir,
                output_file, toplevel_build, output_file_name, flavor,
                toplevel_dir=None):
     """
     base_dir: path from source root to directory containing this gyp file,
               by gyp semantics, all input paths are relative to this
     build_dir: path from source root to build output
     toplevel_dir: path to the toplevel directory
     """
 
@@ skipping 419 matching lines @@
       # TODO: if the command references the outputs directly, we should
       # simplify it to just use $out.
 
       # Rules can potentially make use of some special variables which
       # must vary per source file.
       # Compute the list of variables we'll need to provide.
       special_locals = ('source', 'root', 'dirname', 'ext', 'name')
       needed_variables = set(['source'])
       for argument in args:
         for var in special_locals:
-          if ('${%s}' % var) in argument:
+          if '${%s}' % var in argument:
             needed_variables.add(var)
 
       def cygwin_munge(path):
+        # pylint: disable=cell-var-from-loop
         if is_cygwin:
           return path.replace('\\', '/')
         return path
 
       inputs = [self.GypPathToNinja(i, env) for i in rule.get('inputs', [])]
 
       # If there are n source files matching the rule, and m additional rule
       # inputs, then adding 'inputs' to each build edge written below will
       # write m * n inputs. Collapsing reduces this to m + n.
       sources = rule.get('rule_sources', [])
@@ skipping 485 matching lines @@
       if def_file:
         implicit_deps.add(def_file)
     else:
       # Respect environment variables related to build, but target-specific
       # flags can still override them.
       ldflags = env_ldflags + config.get('ldflags', [])
       if is_executable and len(solibs):
         rpath = 'lib/'
         if self.toolset != 'target':
           rpath += self.toolset
-        ldflags.append('-Wl,-rpath=\$$ORIGIN/%s' % rpath)
+        ldflags.append(r'-Wl,-rpath=\$$ORIGIN/%s' % rpath)
         ldflags.append('-Wl,-rpath-link=%s' % rpath)
     self.WriteVariableList(ninja_file, 'ldflags',
                            gyp.common.uniquer(map(self.ExpandSpecial, ldflags)))
 
     library_dirs = config.get('library_dirs', [])
     if self.flavor == 'win':
       library_dirs = [self.msvs_settings.ConvertVSMacros(l, config_name)
                       for l in library_dirs]
       library_dirs = ['/LIBPATH:' + QuoteShellArgument(self.GypPathToNinja(l),
                                                        self.flavor)
@@ skipping 1198 matching lines @@
           arglists.append(
               (target_list, target_dicts, data, params, config_name))
         pool.map(CallGenerateOutputForConfig, arglists)
       except KeyboardInterrupt, e:
         pool.terminate()
         raise e
     else:
       for config_name in config_names:
         GenerateOutputForConfig(target_list, target_dicts, data, params,
                                 config_name)