@Override public String getAndSaveNicknameFor(TypeAlias alias) { String[] parts = alias.getFullName().split(";", -1); if (parts.length == 4) { imports.put(parts[0], TypeAlias.create(parts[0], parts[1])); } return alias.getNickname(); }
private void updateOldImports(String shortName, Collection<TypeAlias> aliases) { for (TypeAlias alias : aliases) { String className = alias.getNickname().substring(alias.getNickname().indexOf(".") + 1); getAndSaveNicknameFor( TypeAlias.createAliasedImport(alias.getFullName(), shortName + "." + className)); } }
/** * Creates a type alias for an inner type with the given fullName and referenced by nickname, with * an import of outerTypeName. */ public static TypeName createOuterTypeName( String fullName, String nickname, String outerTypeName) { TypeAlias typeAlias = TypeAlias.createOuterImport(fullName, nickname, outerTypeName); return new TypeName(typeAlias); }
/** * Returns true if the alias needs to be imported to refer to it only through the nickname. This * will be false if the full name and nickname are the same. */ public boolean needsImport() { return !getFullName().equals(getNickname()); }
@Override public String getAndSaveNicknameFor(TypeAlias alias) { if (!alias.needsImport()) { return alias.getNickname(); } // Derive a short name if possible if (imports.containsKey(alias.getFullName())) { // Short name already there. return imports.get(alias.getFullName()).getNickname(); } // TODO: Handle name clashes imports.put(alias.getFullName(), alias); return alias.getNickname(); }
@Test public void testDisambiguate_move2Packages() { PythonTypeTable typeTable = new PythonTypeTable("foo.bar"); assertThat(typeTable.getAndSaveNicknameFor(TypeAlias.create("a.c.d.E", "c_d.E"))) .isEqualTo("c_d.E"); assertThat(typeTable.getAndSaveNicknameFor(TypeAlias.create("b.c.d.F", "c_d.F"))) .isEqualTo("b_c_d.F"); Map<String, TypeAlias> imports = typeTable.getImports(); assertThat(imports.get("a.c.d.E").getNickname()).isEqualTo("a_c_d.E"); assertThat(imports.get("b.c.d.F").getNickname()).isEqualTo("b_c_d.F"); }
@Override public String getAndSaveNicknameFor(TypeAlias alias) { if (!alias.needsImport()) { return alias.getNickname(); String shortName = alias.getNickname().substring(0, alias.getNickname().indexOf(".")); String className = alias.getNickname().substring(alias.getNickname().indexOf(".") + 1); String moduleName = alias.getFullName().substring(0, alias.getFullName().length() - className.length() - 1); if (usedShortNames.containsKey(shortName)) { return alias.getNickname(); TypeAlias.createAliasedImport( alias.getFullName(), disambiguatedNewShortName + "." + className)); TypeAlias.createAliasedImport(alias.getFullName(), newShortName + "." + className)); return alias.getNickname();
/** Creates a type alias for a static inner type with the given fullName and nickname. */ public TypeName(String fullName, String nickname, String parentTypeName) { this(TypeAlias.create(fullName, nickname, parentTypeName)); }
public ImportSectionView generateImportSection( Map<String, TypeAlias> typeImports, String className) { ImmutableList.Builder<ImportFileView> appImports = ImmutableList.builder(); for (TypeAlias alias : typeImports.values()) { if (excludeAppImport(alias, className)) { continue; } ImportTypeView.Builder imp = ImportTypeView.newBuilder(); switch (alias.getImportType()) { case OuterImport: imp.fullName(alias.getParentFullName()); break; default: imp.fullName(alias.getFullName()); break; } imp.nickname(alias.getNickname()); imp.type(alias.getImportType()); appImports.add(ImportFileView.newBuilder().types(ImmutableList.of(imp.build())).build()); } return ImportSectionView.newBuilder().appImports(appImports.build()).build(); }
@Override public int compare(TypeAlias o1, TypeAlias o2) { return o1.getNickname().compareTo(o2.getNickname()); } };
public ImportSectionView generateImportSection(Map<String, TypeAlias> typeImports) { ImmutableList.Builder<ImportFileView> standardImports = ImmutableList.builder(); ImmutableList.Builder<ImportFileView> externalImports = ImmutableList.builder(); for (TypeAlias alias : typeImports.values()) { String importPath = alias.getFullName(); ImportTypeView.Builder imp = ImportTypeView.newBuilder(); imp.fullName('"' + importPath + '"'); imp.nickname(alias.getNickname()); imp.type(alias.getImportType()); ImmutableList.Builder<ImportFileView> target = isStandardImport(importPath) ? standardImports : externalImports; target.add(ImportFileView.newBuilder().types(ImmutableList.of(imp.build())).build()); } return ImportSectionView.newBuilder() .standardImports(standardImports.build()) .externalImports(externalImports.build()) .build(); }
/** Package-private for use in PhpGapicSurfaceTestTransformer */ ImportSectionView generateImportSection(Map<String, TypeAlias> typeImports) { ImmutableList.Builder<ImportFileView> appImports = ImmutableList.builder(); for (Map.Entry<String, TypeAlias> entry : typeImports.entrySet()) { String key = entry.getKey(); TypeAlias alias = entry.getValue(); // Remove leading backslash because it is not required by PHP use statements String fullName = key.startsWith("\\") ? key.substring(1) : key; ImportTypeView.Builder imp = ImportTypeView.newBuilder(); imp.fullName(fullName); imp.nickname(alias.getNickname()); imp.type(alias.getImportType()); appImports.add(ImportFileView.newBuilder().types(ImmutableList.of(imp.build())).build()); } return ImportSectionView.newBuilder().appImports(appImports.build()).build(); } }
private boolean excludeAppImport(TypeAlias alias, String className) { String parentFullName = alias.getParentFullName(); if (className == null || alias.getImportType() != ImportType.StaticImport || parentFullName == null || !parentFullName.endsWith(className)) { return false; } // Trying to handle cases when className is a suffix of the actual parrent name in a // language-agnostic way. For example: // parentFullName = "package.path.ParentTheClass"; // className = "TheClass" ; // should return false, but: // parentFullName = "package.path.ParentTheClass"; // className = "ParentTheClass"; // should return true. // // It is also assumed that everything in full class name which is not a letter/digit/underscore // is a path separator. This should be good enough for all languages that we support. if (parentFullName.length() > className.length()) { char packageSeparator = parentFullName.charAt(parentFullName.length() - className.length() - 1); if (Character.isLetterOrDigit(packageSeparator) || '_' == packageSeparator) { return false; } } return true; }
@Override public Map<String, TypeAlias> getImports() { ImmutableMap.Builder<String, TypeAlias> imports = ImmutableMap.builder(); for (Collection<TypeAlias> aliases : moduleImports.asMap().values()) { TypeAlias alias = aliases.iterator().next(); imports.put(alias.getFullName(), alias); } return imports.build(); }
@Override public Map<String, TypeAlias> getImports() { TreeMap<TypeAlias, String> inverseMap = new TreeMap<>(TypeAlias.getNicknameComparator()); inverseMap.putAll(dynamicTypeTable.getImportsBimap().inverse()); return HashBiMap.create(inverseMap).inverse(); }
@Test public void testDisambiguate_movePackage() { PythonTypeTable typeTable = new PythonTypeTable("foo.bar"); assertThat(typeTable.getAndSaveNicknameFor(TypeAlias.create("a.c.D", "c.D"))).isEqualTo("c.D"); assertThat(typeTable.getAndSaveNicknameFor(TypeAlias.create("b.c.E", "c.E"))) .isEqualTo("b_c.E"); Map<String, TypeAlias> imports = typeTable.getImports(); assertThat(imports.get("a.c.D").getNickname()).isEqualTo("a_c.D"); assertThat(imports.get("b.c.E").getNickname()).isEqualTo("b_c.E"); }
@Override public String getAndSaveNicknameFor(TypeAlias alias) { if (!alias.needsImport()) { return alias.getNickname(); } // Derive a short name if possible if (imports.containsKey(alias.getFullName())) { // Short name already there. return imports.get(alias.getFullName()).getNickname(); } if (usedNicknames.contains(alias.getNickname())) { // Short name clashes, use long name. return alias.getFullName(); } imports.put(alias.getFullName(), alias); usedNicknames.add(alias.getNickname()); return alias.getNickname(); }
/** Creates a TypeAlias where the fullName and nickname are the same. */ public static TypeAlias create(String name) { return create(name, name); }
private List<ImportFileView> generateFileHeaderAppImports(Map<String, TypeAlias> typeImports) { List<ImportFileView> appImports = new ArrayList<>(); for (Map.Entry<String, TypeAlias> entry : typeImports.entrySet()) { appImports.add(generateAppImport(entry.getKey(), entry.getValue().getNickname())); } Collections.sort(appImports, importFileViewComparator()); return appImports; }
/** Renders the fully-qualified name of this type given its pattern. */ public String getFullName() { if (pattern == null) { return topLevelAlias.getFullName(); } String result = StringUtils.replaceOnce(pattern, "%s", topLevelAlias.getFullName()); for (TypeName innerTypeName : innerTypeNames) { result = StringUtils.replaceOnce(result, "%i", innerTypeName.getFullName()); } return result; }