tools/telemetry/catapult_base/refactor/annotated_symbol/import_statement.py

   1 # Copyright 2015 The Chromium Authors. All rights reserved.
   2 # Use of this source code is governed by a BSD-style license that can be
   3 # found in the LICENSE file.
   4
   5 import itertools
   6 import keyword
   7 import symbol
   8 import token
   9
  10 from catapult_base.refactor.annotated_symbol import base_symbol
  11 from catapult_base.refactor import snippet
  12
  13
  14 __all__ = [
  15     'AsName',
  16     'DottedName',
  17     'Import',
  18     'ImportFrom',
  19     'ImportName',
  20 ]
  21
  22
  23 class DottedName(base_symbol.AnnotatedSymbol):
  24   @classmethod
  25   def Annotate(cls, symbol_type, children):
  26     if symbol_type != symbol.dotted_name:
  27       return None
  28     return cls(symbol_type, children)
  29
  30   @property
  31   def value(self):
  32     return ''.join(token_snippet.value for token_snippet in self._children)
  33
  34   @value.setter
  35   def value(self, value):
  36     value_parts = value.split('.')
  37     for value_part in value_parts:
  38       if keyword.iskeyword(value_part):
  39         raise ValueError('%s is a reserved keyword.' % value_part)
  40
  41     # If we have too many children, cut the list down to size.
  42     self._children = self._children[:len(value_parts)*2-1]
  43
  44     # Update child nodes.
  45     for child, value_part in itertools.izip_longest(
  46         self._children[::2], value_parts):
  47       if child:
  48         # Modify existing children. This helps preserve comments and spaces.
  49         child.value = value_part
  50       else:
  51         # Add children as needed.
  52         self._children.append(snippet.TokenSnippet.Create(token.DOT, '.'))
  53         self._children.append(
  54             snippet.TokenSnippet.Create(token.NAME, value_part))
  55
  56
  57 class AsName(base_symbol.AnnotatedSymbol):
  58   @classmethod
  59   def Annotate(cls, symbol_type, children):
  60     if (symbol_type != symbol.dotted_as_name and
  61         symbol_type != symbol.import_as_name):
  62       return None
  63     return cls(symbol_type, children)
  64
  65   @property
  66   def name(self):
  67     return self.children[0].value
  68
  69   @name.setter
  70   def name(self, value):
  71     self.children[0].value = value
  72
  73   @property
  74   def alias(self):
  75     if len(self.children) < 3:
  76       return None
  77     return self.children[2].value
  78
  79   @alias.setter
  80   def alias(self, value):
  81     if keyword.iskeyword(value):
  82       raise ValueError('%s is a reserved keyword.' % value)
  83
  84     if value:
  85       if len(self.children) < 3:
  86         # If we currently have no alias, add one.
  87         self.children.append(
  88             snippet.TokenSnippet.Create(token.NAME, 'as', (0, 1)))
  89         self.children.append(
  90             snippet.TokenSnippet.Create(token.NAME, value, (0, 1)))
  91       else:
  92         # We already have an alias. Just update the value.
  93         self.children[2].value = value
  94     else:
  95       # Removing the alias. Strip the "as foo".
  96       self.children = [self.children[0]]
  97
  98
  99 class Import(base_symbol.AnnotatedSymbol):
 100   """An import statement.
 101
 102   Example:
 103     import a.b.c as d
 104     from a.b import c as d
 105
 106   In these examples,
 107     path == 'a.b.c'
 108     alias == 'd'
 109     root == 'a.b' (only for "from" imports)
 110     module == 'c' (only for "from" imports)
 111     name (read-only) == the name used by references to the module, which is the
 112     alias if there is one, the full module path in "full" imports, and the
 113     module name in "from" imports.
 114   """
 115   @property
 116   def has_from(self):
 117     """Returns True iff the import statment is of the form "from x import y"."""
 118     raise NotImplementedError()
 119
 120   @property
 121   def values(self):
 122     raise NotImplementedError()
 123
 124   @property
 125   def paths(self):
 126     raise NotImplementedError()
 127
 128   @property
 129   def aliases(self):
 130     raise NotImplementedError()
 131
 132   @property
 133   def path(self):
 134     """The full dotted path of the module."""
 135     raise NotImplementedError()
 136
 137   @path.setter
 138   def path(self, value):
 139     raise NotImplementedError()
 140
 141   @property
 142   def alias(self):
 143     """The alias, if the module is renamed with "as". None otherwise."""
 144     raise NotImplementedError()
 145
 146   @alias.setter
 147   def alias(self, value):
 148     raise NotImplementedError()
 149
 150   @property
 151   def name(self):
 152     """The name used to reference this import's module."""
 153     raise NotImplementedError()
 154
 155
 156 class ImportName(Import):
 157   @classmethod
 158   def Annotate(cls, symbol_type, children):
 159     if symbol_type != symbol.import_stmt:
 160       return None
 161     if children[0].type != symbol.import_name:
 162       return None
 163     assert len(children) == 1
 164     return cls(symbol_type, children[0].children)
 165
 166   @property
 167   def has_from(self):
 168     return False
 169
 170   @property
 171   def values(self):
 172     dotted_as_names = self.children[1]
 173     return tuple((dotted_as_name.name, dotted_as_name.alias)
 174                  for dotted_as_name in dotted_as_names.children[::2])
 175
 176   @property
 177   def paths(self):
 178     return tuple(path for path, _ in self.values)
 179
 180   @property
 181   def aliases(self):
 182     return tuple(alias for _, alias in self.values)
 183
 184   @property
 185   def _dotted_as_name(self):
 186     dotted_as_names = self.children[1]
 187     if len(dotted_as_names.children) != 1:
 188       raise NotImplementedError(
 189           'This method only works if the statement has one import.')
 190     return dotted_as_names.children[0]
 191
 192   @property
 193   def path(self):
 194     return self._dotted_as_name.name
 195
 196   @path.setter
 197   def path(self, value):  # pylint: disable=arguments-differ
 198     self._dotted_as_name.name = value
 199
 200   @property
 201   def alias(self):
 202     return self._dotted_as_name.alias
 203
 204   @alias.setter
 205   def alias(self, value):  # pylint: disable=arguments-differ
 206     self._dotted_as_name.alias = value
 207
 208   @property
 209   def name(self):
 210     if self.alias:
 211       return self.alias
 212     else:
 213       return self.path
 214
 215
 216 class ImportFrom(Import):
 217   @classmethod
 218   def Annotate(cls, symbol_type, children):
 219     if symbol_type != symbol.import_stmt:
 220       return None
 221     if children[0].type != symbol.import_from:
 222       return None
 223     assert len(children) == 1
 224     return cls(symbol_type, children[0].children)
 225
 226   @property
 227   def has_from(self):
 228     return True
 229
 230   @property
 231   def values(self):
 232     try:
 233       import_as_names = self.FindChild(symbol.import_as_names)
 234     except ValueError:
 235       return (('*', None),)
 236
 237     return tuple((import_as_name.name, import_as_name.alias)
 238                  for import_as_name in import_as_names.children[::2])
 239
 240   @property
 241   def paths(self):
 242     module = self.module
 243     return tuple('.'.join((module, name)) for name, _ in self.values)
 244
 245   @property
 246   def aliases(self):
 247     return tuple(alias for _, alias in self.values)
 248
 249   @property
 250   def root(self):
 251     return self.FindChild(symbol.dotted_name).value
 252
 253   @root.setter
 254   def root(self, value):
 255     self.FindChild(symbol.dotted_name).value = value
 256
 257   @property
 258   def _import_as_name(self):
 259     try:
 260       import_as_names = self.FindChild(symbol.import_as_names)
 261     except ValueError:
 262       return None
 263
 264     if len(import_as_names.children) != 1:
 265       raise NotImplementedError(
 266           'This method only works if the statement has one import.')
 267
 268     return import_as_names.children[0]
 269
 270   @property
 271   def module(self):
 272     import_as_name = self._import_as_name
 273     if import_as_name:
 274       return import_as_name.name
 275     else:
 276       return '*'
 277
 278   @module.setter
 279   def module(self, value):
 280     if keyword.iskeyword(value):
 281       raise ValueError('%s is a reserved keyword.' % value)
 282
 283     import_as_name = self._import_as_name
 284     if value == '*':
 285       # TODO: Implement this.
 286       raise NotImplementedError()
 287     else:
 288       if import_as_name:
 289         import_as_name.name = value
 290       else:
 291         # TODO: Implement this.
 292         raise NotImplementedError()
 293
 294   @property
 295   def path(self):
 296     return '.'.join((self.root, self.module))
 297
 298   @path.setter
 299   def path(self, value):  # pylint: disable=arguments-differ
 300     self.root, _, self.module = value.rpartition('.')
 301
 302   @property
 303   def alias(self):
 304     import_as_name = self._import_as_name
 305     if import_as_name:
 306       return import_as_name.alias
 307     else:
 308       return None
 309
 310   @alias.setter
 311   def alias(self, value):  # pylint: disable=arguments-differ
 312     import_as_name = self._import_as_name
 313     if not import_as_name:
 314       raise NotImplementedError('Cannot change alias for "import *".')
 315     import_as_name.alias = value
 316
 317   @property
 318   def name(self):
 319     if self.alias:
 320       return self.alias
 321     else:
 322       return self.module