| OLD | NEW |
|---|
| (Empty) |
| 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 | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1599413006:
Remove catapult_base from telemetry. (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@perf_cb_move