Merge latest ninja_syntax.py from upstream.

pylib/gyp/ninja_syntax.py

 # This file comes from
 #   https://github.com/martine/ninja/blob/master/misc/ninja_syntax.py
 # Do not edit!  Edit the upstream one instead.
 
 """Python module for generating .ninja files.
 
 Note that this is emphatically not a required piece of Ninja; it's
 just a helpful utility for build-file-generation systems that already
 use Python.
 """
@@ skipping 40 matching lines @@
             self.variable('restat', '1', indent=1)
         if rspfile:
             self.variable('rspfile', rspfile, indent=1)
         if rspfile_content:
             self.variable('rspfile_content', rspfile_content, indent=1)
 
     def build(self, outputs, rule, inputs=None, implicit=None, order_only=None,
               variables=None):
         outputs = self._as_list(outputs)
         all_inputs = self._as_list(inputs)[:]
-        out_outputs = map(escape_spaces, outputs)
-        all_inputs = map(escape_spaces, all_inputs)
+        out_outputs = list(map(escape_spaces, outputs))
+        all_inputs = list(map(escape_spaces, all_inputs))
 
         if implicit:
             implicit = map(escape_spaces, self._as_list(implicit))
             all_inputs.append('|')
             all_inputs.extend(implicit)
         if order_only:
             order_only = map(escape_spaces, self._as_list(order_only))
             all_inputs.append('||')
             all_inputs.extend(order_only)
 
         self._line('build %s: %s %s' % (' '.join(out_outputs),
                                         rule,
                                         ' '.join(all_inputs)))
 
         if variables:
-            for key, val in variables:
+            if isinstance(variables, dict):
+                iterator = variables.iteritems()
+            else:
+                iterator = iter(variables)
+
+            for key, val in iterator:
                 self.variable(key, val, indent=1)
 
         return outputs
 
     def include(self, path):
         self._line('include %s' % path)
 
     def subninja(self, path):
         self._line('subninja %s' % path)
 
     def default(self, paths):
         self._line('default %s' % ' '.join(self._as_list(paths)))
 
     def _count_dollars_before_index(self, s, i):
       """Returns the number of '$' characters right in front of s[i]."""
       dollar_count = 0
       dollar_index = i - 1
       while dollar_index > 0 and s[dollar_index] == '$':
         dollar_count += 1
         dollar_index -= 1
       return dollar_count
 
     def _line(self, text, indent=0):
         """Write 'text' word-wrapped at self.width characters."""
         leading_space = '  ' * indent
-        while len(text) > self.width:
+        while len(leading_space) + len(text) > self.width:
             # The text is too wide; wrap if possible.
 
             # Find the rightmost space that would obey our width constraint and
             # that's not an escaped space.
             available_space = self.width - len(leading_space) - len(' $')
             space = available_space
             while True:
               space = text.rfind(' ', 0, space)
               if space < 0 or \
                  self._count_dollars_before_index(text, space) % 2 == 0:
@@ skipping 26 matching lines @@
             return input
         return [input]
 
 
 def escape(string):
     """Escape a string such that it can be embedded into a Ninja file without
     further interpretation."""
     assert '\n' not in string, 'Ninja syntax does not allow newlines'
     # We only have one special metacharacter: '$'.
     return string.replace('$', '$$')