Showing 4,841 of 7,782 total issues
Function setMatcher
has 70 lines of code (exceeds 25 allowed). Consider refactoring. Open
function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) {
if ( postFilter && !postFilter[ expando ] ) {
postFilter = setMatcher( postFilter );
}
if ( postFinder && !postFinder[ expando ] ) {
Function done
has 70 lines of code (exceeds 25 allowed). Consider refactoring. Open
function done( status, nativeStatusText, responses, headers ) {
var isSuccess, success, error, response, modified,
statusText = nativeStatusText;
// Ignore repeat invocations
File ProxyHelper.java
has 283 lines of code (exceeds 250 allowed). Consider refactoring. Open
/** ProxyHelper.java.
Purpose:
Description:
Method jjMoveStringLiteralDfa1_2
has 69 lines of code (exceeds 25 allowed). Consider refactoring. Open
private int jjMoveStringLiteralDfa1_2(long active0)
{
try { curChar = input_stream.readChar(); }
catch(java.io.IOException e) {
jjStopStringLiteralDfa_2(0, active0);
Method jjMoveStringLiteralDfa1_1
has 69 lines of code (exceeds 25 allowed). Consider refactoring. Open
private int jjMoveStringLiteralDfa1_1(long active0)
{
try { curChar = input_stream.readChar(); }
catch(java.io.IOException e) {
jjStopStringLiteralDfa_1(0, active0);
Method writeAppInfo
has 69 lines of code (exceeds 25 allowed). Consider refactoring. Open
private void writeAppInfo(RequestContext reqctx, OutputStream out, WebApp wapp) throws IOException, ServletException {
final String verInfoEnabled = Library.getProperty("org.zkoss.zk.ui.versionInfo.enabled", "true");
final boolean exposeVer = "true".equals(verInfoEnabled);
final StringBuffer sb = new StringBuffer(256);
if (exposeVer)
Method execCreateChild0
has 69 lines of code (exceeds 25 allowed). Consider refactoring. Open
private static Component execCreateChild0(CreateInfo ci, Component parent, ComponentInfo childInfo,
String replaceableText, Component insertBefore) {
Composer composer = childInfo.resolveComposer(ci.page, parent);
ComposerExt composerExt = null;
boolean bPopComposer = false;
Function resolve
has 69 lines of code (exceeds 25 allowed). Consider refactoring. Open
function resolve( depth, deferred, handler, special ) {
return function() {
var that = this,
args = arguments,
mightThrow = function() {
Function _sanitizeElements
has 69 lines of code (exceeds 25 allowed). Consider refactoring. Open
const _sanitizeElements = function _sanitizeElements(currentNode) {
let content = null;
/* Execute a hook if present */
_executeHook('beforeSanitizeElements', currentNode, null);
Function listbox$mold$
has 69 lines of code (exceeds 25 allowed). Consider refactoring. Open
function listbox$mold$(out) {
var uuid = this.uuid,
zclsHTML = this.getZclass(),
innerWidth = zUtl.encodeXML(this.getInnerWidth()),
wdAttr = innerWidth === '100%' ? ' width="100%"' : '',
Method normalize
has a Cognitive Complexity of 20 (exceeds 5 allowed). Consider refactoring. Open
public static final String normalize(String path) {
if (path == null)
return "";
//remove consecutive slashes
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Method parseMethod
has a Cognitive Complexity of 20 (exceeds 5 allowed). Consider refactoring. Open
public static final MethodInfo parseMethod(String signature)
throws IllegalSyntaxException {
int len = signature.length();
int j = Strings.skipWhitespaces(signature, 0);
int k = Strings.anyOf(signature, "( \t\n\r", j);
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Method init
has a Cognitive Complexity of 20 (exceeds 5 allowed). Consider refactoring. Open
public void init() throws ServletException {
final ServletContext ctx = getServletContext();
final ServletConfig config = getServletConfig();
String param = config.getInitParameter("compress");
if (param != null)
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Method treeSelect
has a Cognitive Complexity of 20 (exceeds 5 allowed). Consider refactoring. Open
@Command
public void treeSelect(
@ContextParam(ContextType.TRIGGER_EVENT) SelectEvent event) {
// Clients.log("selection count before select "
// + treeModel.getSelectionCount());
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Method outEndJavaScriptFunc
has a Cognitive Complexity of 20 (exceeds 5 allowed). Consider refactoring. Open
private static void outEndJavaScriptFunc(Execution exec, Writer out, String extra, boolean aupg, boolean afterLoad)
throws IOException {
final String ac = outResponseJavaScripts(exec, true);
if (aupg) {
if (extra.length() > 0 || ac.length() > 0) {
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Method getVisibleChildren
has a Cognitive Complexity of 20 (exceeds 5 allowed). Consider refactoring. Open
public static Collection<Component> getVisibleChildren(Component comp) {
final Collection<Component> children = comp.getChildren();
return new AbstractCollection<Component>() {
public int size() {
int size = 0;
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Method parsePageDirective
has a Cognitive Complexity of 20 (exceeds 5 allowed). Consider refactoring. Open
private static void parsePageDirective(PageDefinition pgdef, ProcessingInstruction pi, Map<String, String> params)
throws Exception {
for (Map.Entry<String, String> me : pi.parseData().entrySet()) {
final String nm = me.getKey();
final String val = me.getValue();
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Method getAttributeOrFellow
has a Cognitive Complexity of 20 (exceeds 5 allowed). Consider refactoring. Open
public Object getAttributeOrFellow(String name, boolean recurse) {
Object val = getAttribute(name);
if (val != null || hasAttribute(name))
return val;
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Method enableServerPush
has a Cognitive Complexity of 20 (exceeds 5 allowed). Consider refactoring. Open
private boolean enableServerPush(ServerPush serverPush, boolean enable, Serializable enabler) {
synchronized (enablers) {
boolean enablersEmptyBefore = enablers.isEmpty();
if (enable) {
//handle dummy target
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Method init
has a Cognitive Complexity of 20 (exceeds 5 allowed). Consider refactoring. Open
public void init() throws ServletException {
final ServletConfig config = getServletConfig();
final ServletContext ctx = getServletContext();
ctx.setAttribute(ATTR_UPDATE_SERVLET, this);
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"