https://stackoverflow.com/questions/75154524/bulk-rename-of-...
A number of classes have been renamed to have the Kt prefix. There are other changes that don't yet have the new prefix applied because changing those classes would ripple into, essentially, all the entire classes. Hence the search for a mass rename procedure that works. Suggestions welcome.
Donald Knuth set that rule up so that "plain.tex" would be the same, world-wide. I don't know why the authors applied the same license to the entire Java application, rather than limit it to Knuth's work.
I've also added a comment "// Originally" that indicates the original name of the class, rather than the name of the file. This is a minor violation of the license, but still keeps the spirit if not the letter of the license. Otherwise there'd be no way to extract an inner class.
The (meager) docs on scripting: https://www.jetbrains.com/help/idea/ide-scripting-console.ht.... The plugin docs & intellij source code (especially the unit tests) are a better source of information.
And here's a script that will use intellij's refactoring to rename all classes recursively in a directory to add the prefix Renamed, correctly dealing with references & renaming files if necessary:
@file:Suppress("NAME_SHADOWING")
import com.intellij.notification.Notification
import com.intellij.notification.NotificationType
import com.intellij.notification.Notifications
import com.intellij.openapi.actionSystem.*
import com.intellij.openapi.keymap.KeymapManager
import com.intellij.openapi.command.WriteCommandAction
import com.intellij.psi.*
import com.intellij.psi.search.*
import com.intellij.refactoring.rename.RenameProcessor
import com.intellij.util.ThrowableConsumer
import java.io.PrintWriter
import java.io.StringWriter
import javax.swing.KeyStroke
// Usage: In IDEA: Tools -> IDE Scripting Console -> Kotlin
// Ctrl+A, Ctrl+Enter to run the script
// Select folder containing target classes, Ctrl+Shift+A to open action menu, search for Bulk refactor
//<editor-fold desc="Boilerplate">
val b = bindings as Map<*, *>
val IDE = b["IDE"] as com.intellij.ide.script.IDE
fun registerAction(
name: String,
keyBind: String? = null,
consumer: ThrowableConsumer<AnActionEvent, Throwable>
) {
registerAction(name, keyBind, object : AnAction() {
override fun actionPerformed(event: AnActionEvent) {
try {
consumer.consume(event);
} catch (t: Throwable) {
val sw = StringWriter()
t.printStackTrace(PrintWriter(sw))
log("Exception in action $name: $t\n\n\n$sw", NotificationType.ERROR)
throw t
}
}
});
}
fun registerAction(name: String, keyBind: String? = null, action: AnAction) {
action.templatePresentation.text = name;
action.templatePresentation.description = name;
KeymapManager.getInstance().activeKeymap.removeAllActionShortcuts(name);
ActionManager.getInstance().unregisterAction(name);
ActionManager.getInstance().registerAction(name, action);
if (keyBind != null) {
KeymapManager.getInstance().activeKeymap.addShortcut(
name,
KeyboardShortcut(KeyStroke.getKeyStroke(keyBind), null)
);
}
}
fun log(msg: String, notificationType: NotificationType = NotificationType.INFORMATION) {
log("Scripted Action", msg, notificationType)
}
fun log(
title: String,
msg: String,
notificationType: NotificationType = NotificationType.INFORMATION
) {
Notifications.Bus.notify(
Notification(
"scriptedAction",
title,
msg,
notificationType
)
)
}
//</editor-fold>
registerAction("Bulk refactor") lambda@{ event ->
val project = event.project ?: return@lambda;
val psiElement = event.getData(LangDataKeys.PSI_ELEMENT) ?: return@lambda
log("Bulk refactor for: $psiElement")
WriteCommandAction.writeCommandAction(event.project).withGlobalUndo().run<Throwable> {
psiElement.accept(object : PsiRecursiveElementWalkingVisitor() {
override fun visitElement(element: PsiElement) {
super.visitElement(element);
if (element !is PsiClass) {
return
}
if(element.name?.startsWith("Renamed") == false) {
log("Renaming $element")
RenameProcessor(project, element, "Renamed" + element.name, false, false).run();
}
}
})
}
}
By the way, this should work on all languages that IntelliJ has a language plugin for, not just Java.
> Argument for @NotNull parameter 'module' of org/jetbrains/.../...GroovyRunner must not be null.
The project doesn't have any references to the NotNull annotation, and there are a number of what appear to be compile errors:
https://i.ibb.co/dfxbV4p/rename-script.png
Running with Ctrl+Enter produces:
> @file:Suppress("NAME_SHADOWING")
MultipleCompilationErrorsException: startup failed:
Script1.groovy: 1: Unexpected input: '@file:' @ line 1, column 6.
@file:Suppress("NAME_SHADOWING")
^
1 error
> import com.intellij.notification.Notification
[22 ms]=> null
MultipleCompilationErrorsException: startup failed:
Script4.groovy: 20: Unexpected input: '<*' @ line 20, column 25.
val b = bindings as Map<*, *>
^
1 error
MultipleCompilationErrorsException: startup failed:
Script5.groovy: 25: Unexpected input: 'registerAction(\n name: String,\n keyBind: String? =' @ line 25, column 22.
keyBind: String? = null,
^
1 error
Then run the script like this:
1. In IDEA: Tools -> IDE Scripting Console -> Kotlin
2. Paste in the script
3. Ctrl+A, Ctrl+Enter to load the script. This should show a green "Loaded!" notification
4. Select a folder containing the classes in the Project window
5. Press Ctrl+Shift+A to open action menu
6. Search for Bulk refactor and select it
Also please note the first version of the script had a bug that would open confirmation dialogues for some refactorings, so see the edited script.
No such sub-menu of Tools exists, but that's fine because I've mapped Ctrl+Shift+A to bring up the menu. I installed the Kotlin plugin and tried again. There was a missing import. After fixing the missing import:
[732 ms]=> null
> 4. Select a folder containing the classes in the Project window
> 5. Press Ctrl+Shift+A to open action menu
> 6. Search for Bulk refactor and select it
Opening the menu with Ctrl+Shift+A doesn't show the bulk refactor script, but that could be because I remapped Ctrl+Shift+A and am using the NetBeans keyboard mappings, rather than the IntelliJ map.
Oops :)
When pressing Ctrl+Enter, did you see the green "Loaded!" notification in the bottom right? If so, then I guess installing the Kotlin plugin worked.
> Opening the menu with Ctrl+Shift+A doesn't show the bulk refactor script
The Ctrl+Shift+A menu from the default keymap that I'm talking about is the "Actions" dialog. You can also get there via "Navigate -> Search Everywhere" and then selecting the "Actions" tab (or just searching in All).
Also you only have to select a single folder/package and it will be processed recursively. I did not test what happens when you select multiple folders. Might be fine, might explode.
edit: Just realized the script I pasted here does not emit the "Loaded!" log message on load. So disregard those comments. If you want to verify it loads correctly, add this as the last line:
log("Loaded!")https://i.ibb.co/MP2JNRM/classes-renamed.png
Thank you!
export javas=$(find . -regex '.*\.java$'); for old in $(grep -hrPo 'class (?!Kt)\K[A-Z]\w+'); do echo $old; sed -i "s/\<$old\>/Kt$old/g" $javas; rename "s/^$old\$/Kt$old/" $javas; done
javas=$(find . -regex '.*\.java$')
sed -i -E "$(printf 's/\\<(%s)\\>/Kt\\1/g;' $(grep -hrPo '\b(class|interface|record|enum) (?!Kt)(?!List\b)(?!Entry\b)\K[A-Z]\w+'))" $(echo $javas);
rename 's;\b(?!Kt)(\w+[.]java)$;Kt$1;' $(echo $javas)
The license term seems petty, and would be annoying, but the workaround is trivial.
If you have a trivial solution to rename hundreds of Java classes and their references en masse without breaking the build and without renaming each file one-at-a-time, do tell. You can find more details about potential solutions I've tried here:
https://stackoverflow.com/questions/75154524/bulk-rename-of-...
---
type: specs.openrewrite.org/v1beta/recipe
name: com.yourorg.ChangeTypeExample
displayName: Change type example
recipeList:
- org.openrewrite.java.ChangeType:
oldFullyQualifiedTypeName: (.+)
newFullyQualifiedTypeName: Kt$1- build the current TeX.jar
- jar tf TeX.jar | grep whatever to get a list of to-be-renamed classes
- use sed or manual editing to generate a large list of recipes
- run those recipes
Instead of jar tf, grep for “^package foo.bar.baz” and “class (complex regex)” in the source code to get a list of package and class names, or use the directory structure. Maybe do all of them, and compare the results for robustness.
That list will be large and it may not go perfect in one go, but it’s a one-off job, and you‘ll get there.
It's possible you do in fact need to parse the AST for your goals - I haven't spent the requisite time to deeply understand the problem.
---
Why do you want to change all the files? The license only says you have to change the names of files that you modify. It's a pretty weird term.
If for some reason you were determined to change the names of all files then you ought to be able to create a plugin that walks the tree of classes and invokes the refactoring capabilities of the IDE to make the change. It's a strange use-case though so I'm not really surprised there isn't a ready tool for it.
Ever pull on a thread to unravel an entire sweater?
Imagine wanting to add an SVG typesetter. To do this, the interface implemented by the DVI typesetter needs to be extracted and generalized so that it works for both SVG and DVI (to maintain existing behaviour). The `Typesetter` interface is used by, for example, `BaseNode`, so any changes to that interface could touch `BaseNode`. Changes to `BaseNode` can affect all `*Node` classes, which then cascade over to `*Noad` and `*Prim` classes, and from there the rest of the source base.
So, the workaround can be quite impactful in the end. Renaming the entirety of the code base, potentially.
Moreover, under the following definition in the license:
`Modification' of a file
means any procedure that produces a derivative file under any
applicable law -- that is, a file containing the original file or
a significant portion of it, either verbatim or with modifications
and/or translated into another language.
https://www.newyorker.com/tech/annals-of-technology/dumb-sta...
Actually, I'm fairly sure you can. You just need a custom classloader.
But URLClassLoader does, which definitely has something to do with this.
True, before you get there, you'd first need it to compile - but modern JDKs have a compiler API that allows customization via the StandardJavaFileManager interface, and that looks like it should be able to do the job to make source file names follow a different convention.
> If and only if packages are stored in a file system (§7.2), the host system may choose to enforce the restriction that it is a compile-time error if a class or interface is not found in a file under a name composed of the class or interface name plus an extension (such as .java or .jav) if either of the following is true:
> * The class or interface is referred to by code in other ordinary compilation units of the package in which the class or interface is declared.
> * The class or interface is declared public (and therefore is potentially accessible from code in other packages).
and javac does indeed enforce this restriction, at least for public classes. It's an error to declare a public class called Foo in a file that's called anything except Foo.java.
However, for performance reasons, the JVM loads classes lazily and will only try to find classes in the directory it would be expected to be (either in the directories included in the classpth or in jars). Because you can write your own class loader, you can implement something different (like OSGi does for example - it has much more metadata so it can even load multiple classes with the same name from different jars) but this is the default behaviour.
echo "public class Foo {}" > Bar.java
javac Bar.java
Bar.java:1: error: class Foo is public, should be declared in a file named Foo.java
This is a particularly compelling line from it:
Just in isolation, outside of the other aspects of the license, this is pretty much completely crippling for a Java program.Simply, if you change a file, you can't use the same name. Well, in Java, the name of the file is the name of the class. You can't have the file name differ from the class inside.
That means you can't change a Java file in this codebase.
Fascinating.