Fix pylint warnings: build/gn_helpers.py

build/gn_helpers.py

 # Copyright 2014 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Helper functions useful when writing scripts that integrate with GN.
 
 The main functions are ToGNString and FromGNString which convert between
 serialized GN veriables and Python variables.
 
 To use in a random python file in the build:
@@ skipping 45 matching lines @@
         raise GNException("Dictionary key is not a string.")
       result += "%s = %s\n" % (key, ToGNString(value[key], False))
     return result
 
   if isinstance(value, int):
     return str(value)
 
   raise GNException("Unsupported type when printing to GN.")
 
 
-def FromGNString(input):
+def FromGNString(input_string):
   """Converts the input string from a GN serialized value to Python values.
 
   For details on supported types see GNValueParser.Parse() below.
 
   If your GN script did:
     something = [ "file1", "file2" ]
     args = [ "--values=$something" ]
   The command line would look something like:
     --values="[ \"file1\", \"file2\" ]"
   Which when interpreted as a command line gives the value:
@@ skipping 15 matching lines @@
   Will yield the command line:
     asdf --value=asdf
   The unquoted asdf string will not be valid input to this function, which
   accepts only quoted strings like GN scripts. In such cases, you can just use
   the Python string literal directly.
 
   The main use cases for this is for other types, in particular lists. When
   using string interpolation on a list (as in the top example) the embedded
   strings will be quoted and escaped according to GN rules so the list can be
   re-parsed to get the same result."""
-  parser = GNValueParser(input)
+  parser = GNValueParser(input_string)
   return parser.Parse()
 
 
-def FromGNArgs(input):
+def FromGNArgs(input_string):
   """Converts a string with a bunch of gn arg assignments into a Python dict.
 
   Given a whitespace-separated list of
 
     <ident> = (integer | string | boolean | <list of the former>)
 
   gn assignments, this returns a Python dict, i.e.:
 
     FromGNArgs("foo=true\nbar=1\n") -> { 'foo': True, 'bar': 1 }.
 
   Only simple types and lists supported; variables, structs, calls
   and other, more complicated things are not.
 
   This routine is meant to handle only the simple sorts of values that
   arise in parsing --args.
   """
-  parser = GNValueParser(input)
+  parser = GNValueParser(input_string)
   return parser.ParseArgs()
 
 
 def UnescapeGNString(value):
   """Given a string with GN escaping, returns the unescaped string.
 
   Be careful not to feed with input from a Python parsing function like
   'ast' because it will do Python unescaping, which will be incorrect when
   fed into the GN unescaper."""
   result = ''
@@ skipping 96 matching lines @@
     elif next_char == '"':
       return self.ParseString()
     elif self._ConstantFollows('true'):
       return True
     elif self._ConstantFollows('false'):
       return False
     else:
       raise GNException("Unexpected token: " + self.input[self.cur:])
 
   def _ParseIdent(self):
-    id = ''
+    ident = ''
 
     next_char = self.input[self.cur]
     if not next_char.isalpha() and not next_char=='_':
       raise GNException("Expected an identifier: " + self.input[self.cur:])
 
-    id += next_char
+    ident += next_char
     self.cur += 1
 
     next_char = self.input[self.cur]
     while next_char.isalpha() or next_char.isdigit() or next_char=='_':
-      id += next_char
+      ident += next_char
       self.cur += 1
       next_char = self.input[self.cur]
 
-    return id
+    return ident
 
   def ParseNumber(self):
     self.ConsumeWhitespace()
     if self.IsDone():
       raise GNException('Expected number but got nothing.')
 
     begin = self.cur
 
     # The first character can include a negative sign.
     if not self.IsDone() and _IsDigitOrMinus(self.input[self.cur]):
@@ skipping 76 matching lines @@
     location in the input. If it does, the text is consumed and the function
     returns true. Otherwise, returns false and the current position is
     unchanged."""
     end = self.cur + len(constant)
     if end > len(self.input):
       return False  # Not enough room.
     if self.input[self.cur:end] == constant:
       self.cur = end
       return True
     return False