Sign upLogin

silentbalanceyh/vertx-zero

View on GitHub
Star

Showing 7,269 of 9,050 total issues

Method bugAt has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
Open

    public static void bugAt(final boolean condition, final HLogger logger,
                             final ProgramActuator trueActuator, final ProgramActuator falseActuator) throws ProgramException {
        if (condition) {
            bugAt(trueActuator, logger);
        } else {
Severity: Minor
Found in vertx-gaia/vertx-ams/src/main/java/io/horizon/fn/_Bug.java - About 25 mins to fix

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 recordServer has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
Open

    private void recordServer(final HttpServerOptions options,
                              final Router router) {
        final Integer port = options.getPort();
        final AtomicInteger out = ZeroOption.ATOMIC_LOG.get(port);
        if (VValue.ZERO == out.getAndIncrement()) {
Severity: Minor
Found in vertx-gaia/vertx-rx/src/main/java/io/vertx/rx/micro/ZeroRxAgent.java - About 25 mins to fix

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 equals has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
Open

    @Override
    public boolean equals(final Object o) {
        if (this == o) {
            return true;
        }
Severity: Minor
Found in vertx-gaia/vertx-ams/src/main/java/io/horizon/atom/common/KPair.java - About 25 mins to fix

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 type has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
Open

    @Override
    public Class<?> type(final String field, final String childField) {
        final HMetaField item = this.shape.getOrDefault(field, null);
        if (Objects.isNull(item)) {
            return null;
Severity: Minor
Found in vertx-gaia/vertx-ams/src/main/qas/io/modello/specification/meta/MetaAtom.java - About 25 mins to fix

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 fromJson has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
Open

    static void fromJson(final JsonObject json, final RpcOptions obj) {
        if (json.getValue(KName.NAME) instanceof String) {
            obj.setName(json.getString(KName.NAME));
        }
        if (json.getValue(KName.CONFIG) instanceof JsonObject) {
Severity: Minor
Found in vertx-gaia/vertx-co/src/main/extension/io/vertx/core/RpcOptionsConverter.java - About 25 mins to fix

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 push has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
Open

    @Override
    public Iterable<PushResult> push(final Git git, final boolean force) {
        try {
            final Repository repository = git.getRepository();
            final Set<String> remotes = repository.getRemoteNames();
Severity: Minor
Found in vertx-ifx/zero-ifx-git/src/main/java/io/vertx/up/plugin/git/GitClientImpl.java - About 25 mins to fix

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 outBoolean has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
Open

    private static void outBoolean(final Cell cell, final Object value) {
        final String literal = value.toString();
        if ("true".equalsIgnoreCase(literal) || "false".equalsIgnoreCase(literal)) {
            /*
             * Standard Processing
Severity: Minor
Found in vertx-ifx/zero-ifx-excel/src/main/java/io/vertx/up/plugin/excel/tool/ExOut.java - About 25 mins to fix

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 createCell has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
Open

    private static void createCell(final Sheet sheet, final Row row,
                                   final ExPos pos, final Object value, final Class<?> type) {
        if (value instanceof JsonObject) {
            /*
             * Json Format
Severity: Minor
Found in vertx-ifx/zero-ifx-excel/src/main/java/io/vertx/up/plugin/excel/tool/ExData.java - About 25 mins to fix

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 executeAsync has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
Open

    @Override
    public Future<JsonObject> executeAsync(final JsonObject input) {
        final JsonObject normalized = new JsonObject();
        /*
         * query processing
Severity: Minor
Found in vertx-pin/zero-ui/src/main/modulat/io/vertx/mod/ui/uca/ListCombiner.java - About 25 mins to fix

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 equals has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
Open

    @Override
    public boolean equals(final Object o) {
        if (this == o) {
            return true;
        }
Severity: Minor
Found in vertx-pin/zero-wf/src/main/modulat/io/vertx/mod/workflow/atom/runtime/WRule.java - About 25 mins to fix

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 attachConfig has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
Open

    private Future<JsonObject> attachConfig(final JsonObject formJson) {
        final JsonObject config = new JsonObject();
        Ut.valueToJObject(formJson, KName.METADATA);
        /*
         * Form configuration
Severity: Minor
Found in vertx-pin/zero-ui/src/main/java/cn/vertxup/ui/service/FormService.java - About 25 mins to fix

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 instance has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
Open

    static Register instance(final JsonObject params) {
        if (params.containsKey(KName.RECORD)) {
            final Object record = params.getValue(KName.RECORD);
            if (record instanceof JsonObject) {
                // Json Processing
Severity: Minor
Found in vertx-pin/zero-wf/src/main/modulat/io/vertx/mod/workflow/uca/modeling/Register.java - About 25 mins to fix

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 analyze has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
Open

    @Address(Addr.GRAPH_ANALYZE)
    public Future<JsonObject> analyze(final String key, final String graph, final Integer level) {
        final String graphName = Ut.isNil(graph) ? KWeb.DEPLOY.VERTX_GROUP : graph;
        if (Ut.isNil(key)) {
            return Ux.future(new JsonObject());
Severity: Minor
Found in vertx-pin/zero-graphic/src/main/java/cn/vertxup/graphic/api/GraphActor.java - About 25 mins to fix

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 attack has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
Open

    @Override
    public Handler<RoutingContext> attack(final JtUri uri) {
        /*
         * 「The lifecycle of starting」
         * 1. IN_RULE Specification
Severity: Minor
Found in vertx-pin/zero-jet/src/main/modulat/io/vertx/mod/jet/uca/aim/InAim.java - About 25 mins to fix

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 aclProjection has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
Open

    private static JsonArray aclProjection(final JsonArray original, final Acl acl,
                                           final Predicate<Acl> predicate) {
        final JsonArray projection = Ut.valueJArray(original);
        if (Objects.isNull(acl)) {
            /*
Severity: Minor
Found in vertx-pin/zero-rbac/src/main/modulat/io/vertx/mod/rbac/refine/ScAcl.java - About 25 mins to fix

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 source has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
Open

    public ConcurrentMap<String, JsonArray> source(final JsonObject definition) {
        final JsonObject sourceDictJson = definition.getJsonObject(KName.SOURCE_DICT);
        final ConcurrentMap<String, JsonArray> sourceData = new ConcurrentHashMap<>();
        if (Ut.isNotNil(sourceDictJson)) {
            /*
Severity: Minor
Found in vertx-pin/zero-ambient/src/main/jib/io/horizon/spi/component/ExAttributeComponent.java - About 25 mins to fix

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 ark has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
Open

    static HArk ark(final MultiMap headers) {
        /* 1. X-App-Id 检索 */
        final String appId = headers.get(KWeb.HEADER.X_APP_ID);
        if (Ut.isNotNil(appId)) {
            return ark(appId);
Severity: Minor
Found in vertx-pin/zero-ke/src/main/java/io/vertx/mod/ke/refine/KeApp.java - About 25 mins to fix

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 switchAsync has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
Open

    public Future<Arrow> switchAsync(final JsonObject data, final Supplier<Arrow> supplier) {
        if (this.dynamic) {
            if (Objects.isNull(this.switcher)) {
                // Switcher is not configured
                return Ux.future(this.arrow(supplier, this.atom, this.dao));
Severity: Minor
Found in vertx-pin/zero-vie/src/main/jib/io/mature/extension/uca/plugin/AgileSwitcher.java - About 25 mins to fix

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 initializeMatrix has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
Open

    private KMarkAttribute initializeMatrix(final MAttribute attribute) {
        final StringBuilder literal = new StringBuilder();
        // Boolean -> 0, 1
        final List<Boolean> values = new ArrayList<>();
        values.add(attribute.getActive());
Severity: Minor
Found in vertx-pin/zero-atom/src/main/modulat/io/vertx/mod/atom/modeling/builtin/AtomAttribute.java - About 25 mins to fix

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 toCount has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
Open

    public static Long toCount(final Result<Record> result) {
        if (Objects.isNull(result) || result.isEmpty()) {
            return 0L;
        } else {
            final Record record = result.get(VValue.IDX);
Severity: Minor
Found in vertx-pin/zero-atom/src/main/modeler/io/modello/dynamic/modular/jooq/internal/Jq.java - About 25 mins to fix

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

Severity
Category
Status
Source
Language