Sign upLogin

phodal/chapi

View on GitHub
Star

Showing 73 of 364 total issues

Method codeCallFromExprList has 28 lines of code (exceeds 25 allowed). Consider refactoring.
Open

    private fun codeCallFromExprList(primaryExprCtx: GoParser.PrimaryExprContext): CodeCall {
        return when (val child = primaryExprCtx.getChild(0)) {
            is GoParser.OperandContext -> {
                CodeCall(NodeName = child.text)
            }
Severity: Minor
Found in chapi-ast-go/src/main/kotlin/chapi/ast/goast/GoFullIdentListener.kt - About 1 hr to fix

    Method parseParenthesizedExpression has 27 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

        private fun parseParenthesizedExpression(context: ParenthesizedExpressionContext): List<CodeProperty> {
        return context.expressionSequence().singleExpression().map { subSingle ->
            var parameter = CodeProperty(TypeValue = "", TypeType = "object")

            when (subSingle) {
    Severity: Minor
    Found in chapi-ast-typescript/src/main/kotlin/chapi/ast/typescriptast/TypeScriptFullIdentListener.kt - About 1 hr to fix

      Method buildMethodParameters has 27 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

          fun buildMethodParameters(paramListCtx: TypeScriptParser.ParameterListContext?): List<CodeProperty> {
        var parameters: List<CodeProperty> = listOf()

        val type = paramListCtx!!.getChild(0)
        when (type.parent) {
      Severity: Minor
      Found in chapi-ast-typescript/src/main/kotlin/chapi/ast/typescriptast/TypeScriptAstListener.kt - About 1 hr to fix

        Method should_success_parse_test_usecase has 27 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

            @Test
    fun should_success_parse_test_usecase() {
        val code = """
        package cc.unitmesh.pick
        Severity: Minor
        Found in chapi-ast-kotlin/src/test/kotlin/chapi/ast/kotlinast/KotlinFunctionCallTest.kt - About 1 hr to fix

          Method shouldIdentifyFirstFunctionCall has 27 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

              @Test
    fun shouldIdentifyFirstFunctionCall() {
        val code = """
            void aX(void);
            int a1(int param1);
          Severity: Minor
          Found in chapi-ast-c/src/test/kotlin/chapi/ast/cast/CFullIdentListenerTest.kt - About 1 hr to fix

            Method toUml should return UML class representation for CodeDataStruct has 26 lines of code (exceeds 25 allowed). Consider refactoring.
            Open

                @Test
    fun `toUml should return UML class representation for CodeDataStruct`() {
        // Given
        val codeDataStruct = CodeDataStruct(
            NodeName = "TestClass",
            Severity: Minor
            Found in chapi-domain/src/test/kotlin/chapi/domain/core/CodeDataStructTest.kt - About 1 hr to fix

              Method enterCreator has 26 lines of code (exceeds 25 allowed). Consider refactoring.
              Open

                  override fun enterCreator(ctx: JavaParser.CreatorContext?) {
        val variableName = ctx!!.getParent().getParent().getChild(0).text
        val allIdentifier = ctx.createdName().identifier()
        for (identifier in allIdentifier!!) {
            val createdName = identifier.text
              Severity: Minor
              Found in chapi-ast-java/src/main/kotlin/chapi/ast/javaast/JavaFullIdentListener.kt - About 1 hr to fix

                Method should_inline_variable has 26 lines of code (exceeds 25 allowed). Consider refactoring.
                Open

                        @Test
        internal fun should_inline_variable() {
            val code = """
package com.thoughtworks.archguard.packages.domain
                Severity: Minor
                Found in chapi-ast-kotlin/src/test/kotlin/chapi/ast/kotlinast/KotlinFullIdentListenerTest.kt - About 1 hr to fix

                  Method enterClassSpecifier has 26 lines of code (exceeds 25 allowed). Consider refactoring.
                  Open

                      override fun enterClassSpecifier(ctx: CPP14Parser.ClassSpecifierContext?) {
        ctx?.classHead()?.let {
            currentNode = CodeDataStruct()

            it.classKey()?.let { keyContext ->
                  Severity: Minor
                  Found in chapi-ast-cpp/src/main/kotlin/chapi/ast/cppast/CPPBasicIdentListener.kt - About 1 hr to fix

                    Consider simplifying this complex logical expression.
                    Open

                                        if ("line" == directiveStr || "error" == directiveStr || "warning" == directiveStr || "define" == directiveStr || "endregion" == directiveStr || "endif" == directiveStr || "pragma" == directiveStr) {
                        compiledTokens = true
                    }
                    Severity: Major
                    Found in chapi-ast-csharp/src/main/kotlin/chapi/ast/csharpast/CSharpAnalyser.kt - About 1 hr to fix

                      Method enterFromBlock has a Cognitive Complexity of 23 (exceeds 20 allowed). Consider refactoring.
                      Open

                          override fun enterFromBlock(ctx: TypeScriptParser.FromBlockContext?) {
        val imp = unQuote(ctx!!.StringLiteral().text)
        val codeImport = CodeImport(
            Source = imp
        )
                      Severity: Minor
                      Found in chapi-ast-typescript/src/main/kotlin/chapi/ast/typescriptast/TypeScriptFullIdentListener.kt - About 45 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 createFunction has 6 arguments (exceeds 4 allowed). Consider refactoring.
                      Open

                              returnType: String,
        annotations: List<CodeAnnotation>,
        packageName: String,
        modifiers: List<String>,
        methodName: String,
                      Severity: Minor
                      Found in chapi-ast-csharp/src/main/kotlin/chapi/ast/csharpast/CSharpAstListener.kt - About 45 mins to fix

                        Avoid too many return statements within this method.
                        Open

                                            return JavaTargetType(
                        targetType = imp.Source,
                        callType = CallType.SUPER
                    )
                        Severity: Major
                        Found in chapi-ast-java/src/main/kotlin/chapi/ast/javaast/JavaFullIdentListener.kt - About 30 mins to fix
                          Severity
                          Category
                          Status
                          Source
                          Language