Source code
package org.apache.kafka.security.authorizer;
import org.apache.kafka.common.internals.Plugin; import org.apache.kafka.common.metrics.Metrics; import org.apache.kafka.common.resource.Resource;
import org.apache.kafka.common.utils.Utils; import org.apache.kafka.server.authorizer.Authorizer; import java.util.Map; public class AuthorizerUtils {
public static Plugin<Authorizer> createAuthorizer(String className, Map<String, Object> configs, Metrics metrics, String key, String role) throws ClassNotFoundException {
Authorizer authorizer = Utils.newInstance(className, Authorizer.class);
authorizer.configure(configs); return Plugin.wrapInstance(authorizer, metrics, key, "role", role);
}
public static boolean isClusterResource(String name) {
return name.equals(Resource.CLUSTER_NAME);
}
}
Run 1
The code reads as a jumbled mess. All imports are crammed onto a single line, making it difficult to scan dependencies. The class structure is minimal and not broken into logical sections. The createAuthorizer method combines object instantiation, configuration, and wrapping into a very dense sequence with poor line separation. The one-line if-less return in isClusterResource is compact but harms readability. Nesting is minimal, but clarity of intent suffers because parameters like 'key' and 'role' are obscure and the hardcoded "role" string is buried in a long line. Action granularity is low—multiple operations happen per line. Overall, the code feels like a rough draft that was never formatted or reviewed for readability.
Run 2
The code is functional but suffers from several readability issues. The package imports are jumbled on a single line, making it hard to scan dependencies. The createAuthorizer method performs multiple actions in a single line (instantiate, configure, and wrap), reducing clarity. The method signature is long and could benefit from line breaks. While the code is logically structured, the lack of whitespace and inconsistent formatting hurts readability. The isClusterResource method is clear but could be more explicit. Overall, the code works but lacks the clean formatting and clear separation of concerns that would make it highly readable.
Run 3
The code is functional but readability suffers from poor structure and presentation. Multiple imports are compressed onto single lines, making the header harder to scan. The createAuthorizer method has moderate length but combines two distinct actions (instantiation and configuration) on one line before the return, reducing clarity. Nesting is flat, which is good, and intent is mostly clear. However, the parameter list is long, and the hardcoded string "role" is confusing without context. Action granularity is inconsistent: some lines contain multiple statements while others are single-purpose. Reading flow is disrupted by the compressed import block and inline return statement. With minor reformatting—one import per line, separating configure and wrap steps, and clarifying the hardcoded string—readability would improve significantly.
Run 1
Code Structure: The two utility methods are logically separated, but placing the class declaration alongside imports weakens organization. Nesting: There is no nested control flow, making both methods easy to follow. Clarity of intent: Descriptive method names and straightforward operations communicate their purposes clearly. Code length: The implementation is concise without unnecessary logic. Action granularity: Multiple imports share lines, and configuration and return statements occupy the same line, reducing scanability. Reading flow: Execution proceeds naturally within each method, but compressed imports and inconsistent statement layout interrupt the visual flow.
Run 2
Code Structure: Two focused utility methods provide logical organization, but compressed imports and the class declaration weaken visual separation. Nesting: Flat method bodies are easy to follow. Clarity of intent: Method names and straightforward operations clearly communicate authorizer creation and cluster-resource identification, though key and role lack context. Code length: Concise, without unnecessary logic, but long declaration and import lines reduce scanability. Action granularity: Multiple imports share lines, and configure and return share a line, obscuring distinct steps. Reading flow: Execution order is natural, but crowded formatting interrupts smooth reading.
Run 3
Code Structure: Two logically separated utility methods provide straightforward organization, although imports and the class declaration are crowded together. Nesting: No nested control flow, making both methods easy to follow. Clarity of intent: Descriptive method names and simple operations communicate purpose clearly. Code length: Concise, with no unnecessary logic or repetition. Action granularity: Multiple imports share lines, and configuration and return statements occupy the same line, weakening visual separation. Reading flow: Execution proceeds naturally from instantiation to configuration to wrapping, but compressed formatting interrupts scanning. Conventional import formatting and one statement per line would substantially improve readability.