Change the way we generate versions

ppapi/generators/idl_release.py

 #!/usr/bin/env python
 # Copyright (c) 2012 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.
 
 """
 IDLRelease for PPAPI
 
 This file defines the behavior of the AST namespace which allows for resolving
 a symbol as one or more AST nodes given a Release or range of Releases.
@@ skipping 89 matching lines @@
       if self.rmax <= rmin:
         return False
     if rmax is not None and self.rmin is not None:
       if self.rmin >= rmax:
         return False
 
     if GetOption('release_debug'):
       InfoOut.Log('%f to %f is in %s' % (rmin, rmax, self))
     return True
 
+  def GetMinMax(self, releases = None):
+    if not releases:
+      return self.rmin, self.rmax
+
+    if not self.rmin:
+      rmin = releases[0]
+    else:
+      rmin = str(self.rmin)
+    if not self.rmax:
+      rmax = releases[-1]
+    else:
+      rmax = str(self.rmax)
+    return (rmin, rmax)
+
+  def SetMin(self, release):
+    assert not self.rmin
+    self.rmin = release
+
   def Error(self, msg):
     ReportReleaseError(msg)
 
   def Warn(self, msg):
     ReportReleaseWarning(msg)
 
 
 #
 # IDLReleaseList
 #
 # IDLReleaseList is a list based container for holding IDLRelease
 # objects in order.  The IDLReleaseList can be added to, and searched by
 # range.  Objects are stored in order, and must be added in order.
 #
 class IDLReleaseList(object):
   def __init__(self):
-    self.nodes = []
+    self._nodes = []
+
+  def GetReleases(self):
+    return self._nodes
 
   def FindRelease(self, release):
-    for node in self.nodes:
+    for node in self._nodes:
       if node.IsRelease(release):
         return node
     return None
 
   def FindRange(self, rmin, rmax):
     assert (rmin == None) or rmin != rmax
 
     out = []
-    for node in self.nodes:
+    for node in self._nodes:
       if node.InRange(rmin, rmax):
         out.append(node)
     return out
 
   def AddNode(self, node):
     if GetOption('release_debug'):
       InfoOut.Log('\nAdding %s %s' % (node.Location(), node))
     last = None
 
     # Check current releases in that namespace
-    for cver in self.nodes:
+    for cver in self._nodes:
       if GetOption('release_debug'): InfoOut.Log('  Checking %s' % cver)
 
       # We should only be missing a 'release' tag for the first item.
       if not node.rmin:
         node.Error('Missing release on overload of previous %s.' %
                    cver.Location())
         return False
 
       # If the node has no max, then set it to this one
       if not cver.rmax:
@@ skipping 13 matching lines @@
     # Otherwise, the previous max and current min should match
     # unless this is the unlikely case of something being only
     # temporarily deprecated.
     if last and last.rmax != node.rmin:
       node.Warn('Gap in release numbers.')
 
     # If we made it here, this new node must be the 'newest'
     # and does not overlap with anything previously added, so
     # we can add it to the end of the list.
     if GetOption('release_debug'): InfoOut.Log('Done %s' % node)
-    self.nodes.append(node)
+    self._nodes.append(node)
     return True
 
 #
 # IDLReleaseMap
 #
 # A release map, can map from an float interface release, to a global
 # release string.
 #
 class IDLReleaseMap(object):
   def __init__(self, release_info):
@@ skipping 10 matching lines @@
 
   def GetVersions(self):
     return self.versions
 
   def GetRelease(self, version):
     return self.version_to_release.get(version, None)
 
   def GetReleases(self):
     return self.releases
 
+  def GetReleaseRange(self):
+    return (self.releases[0], self.releases[-1])
+
+  def GetVersionRange(self):
+    return (self.versions[0], self.version[-1])
+
 #
 # Test Code
 #
 def TestReleaseNode():
   FooXX = IDLRelease(None, None)
   Foo1X = IDLRelease('M14', None)
   Foo23 = IDLRelease('M15', 'M16')
 
   assert FooXX.IsRelease('M13')
   assert FooXX.IsRelease('M14')
@@ skipping 90 matching lines @@
   TestReleaseNode()
   TestReleaseListWarning()
   TestReleaseListError()
   TestReleaseListOK()
   print "Passed"
   return 0
 
 
 if __name__ == '__main__':
   sys.exit(Main(sys.argv[1:]))
+