jpinpoint-kotlin-rules.xml

<?xml version="1.0" encoding="UTF-8"?>
<ruleset name="jpinpoint-kotlin-rules" 
         xmlns="http://pmd.sourceforge.net/ruleset/2.0.0" 
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
         xsi:schemaLocation="http://pmd.sourceforge.net/ruleset/2.0.0 http://pmd.sourceforge.net/ruleset_2_0_0.xsd"> 

<description>
         jPinpoint rules for responsible Kotlin coding, sponsored by Rabobank. Uses PMD-7.
</description>

<!-- IMPORTANT NOTICE: The content of this file is generated. Do not edit this file directly since changes may be lost when this file is regenerated! -->

<!-- BEGIN Included file 'common.xml' -->
    <rule name="AvoidDecimalAndChoiceFormatAsField"
          language="kotlin"
          message="Avoid using NumberFormat, DecimalFormat or ChoiceFormat as field since it is thread-unsafe."
          class="net.sourceforge.pmd.lang.rule.xpath.XPathRule"
          externalInfoUrl="https://github.com/jborgers/PMD-jPinpoint-rules/tree/pmd7/docs/JavaCodePerformance.md#isio01">
        <description>
            Problem: java.text.DecimalFormat and java.text.ChoiceFormat are thread-unsafe.
            Solution: usual solution is to create a new local one when needed in a method.
            (jpinpoint-rules)
        (jpinpoint-rules)</description>
        <priority>1</priority>
        <properties>
            <property name="tag" value="jpinpoint-rule" type="String" description="for-sonar"/>
            <property name="xpath">
                <value><![CDATA[
(: check if at least one java.text imports exists as filter for same named classes in other packages :)
//ImportHeader[.//T-Identifier[@Text='java'] and .//T-Identifier[@Text='text']][1]/ancestor::KotlinFile
(: PrimaryExpression finds the constructors instead of type declarations :)
(: filter matches in functions :)
//TopLevelObject//PrimaryExpression//SimpleIdentifier//T-Identifier[
 (@Text="DecimalFormat" or @Text="ChoiceFormat")
 and not(ancestor::FunctionBody)
]
]]>
                </value>
            </property>
        </properties>
        <example><![CDATA[
class Foo {

    companion object {
        val NUMBER_FORMAT: DecimalFormat = DecimalFormat("###.###") // bad
    }

    private val numFormat: NumberFormat = DecimalFormat("###.###") //bad

    private val limits = doubleArrayOf(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0)
    private val dayOfWeekNames = arrayOf("Sun", "Mon", "Tue", "Wed", "Thur", "Fri", "Sat")
    private val form = ChoiceFormat(limits, dayOfWeekNames) // bad

    fun shouldNotMatchInsideMethod() {
        val format: NumberFormat = DecimalFormat("##.##")
        val choiceFormat = ChoiceFormat(limits, dayOfWeekNames)
    }
}
]]>
        </example>
    </rule>

    <rule name="AvoidImplicitlyRecompilingRegex"
          class="net.sourceforge.pmd.lang.rule.xpath.XPathRule"
          language="kotlin"
          message="String regex method, Pattern.matches or FileSystem.getPathMatcher is used. Implicitly compiles a regex pattern, can be expensive."
          externalInfoUrl="https://github.com/jborgers/PMD-jPinpoint-rules/tree/pmd7/docs/JavaCodePerformance.md#ireu01">
        <description>A regular expression is compiled implicitly on every invocation. Problem: this can be expensive, depending on the length of the regular expression.&#13;
            Solution: Compile the regex pattern only once and assign it to a private static final Pattern field. java.util.Pattern objects are thread-safe so they can be shared among threads.
            (jpinpoint-rules)</description>
        <priority>2</priority>
        <properties>
            <property name="tag" value="jpinpoint-rule" type="String" description="for-sonar"/>
            <property name="xpath">
                <value><![CDATA[
//FunctionDeclaration//PostfixUnaryExpression//SimpleIdentifier/T-Identifier[
    @Text='Regex'
    (: not called on fun parameter :)
    and not(ancestor::PostfixUnaryExpression//CallSuffix//PrimaryExpression//T-Identifier[
        @Text = ancestor::FunctionDeclaration//FunctionValueParameter//Parameter/SimpleIdentifier/T-Identifier/@Text])
    (: not called on 'dynamic' function call :)
    and not(ancestor::PostfixUnaryExpression/PostfixUnarySuffix/CallSuffix//CallSuffix//CallSuffix)
    (: not if based on local variable initialized by fun parameter :)
    and not(ancestor::CallSuffix//PostfixUnaryExpression/PrimaryExpression/SimpleIdentifier/T-Identifier[
        @Text = ancestor::FunctionBody//PropertyDeclaration/VariableDeclaration/SimpleIdentifier/T-Identifier/@Text])
    (: not param in String template in fun parameter :)
    and not(../../../../PostfixUnaryExpression//CallSuffix/ValueArguments/ValueArgument//LineStringContent/T-LineStrRef[
       @Text = ancestor::FunctionDeclaration//Parameter/SimpleIdentifier/T-Identifier/concat('$', @Text)])
    (: not param in String template of class var field :)
    and not(../../../../PostfixUnaryExpression//CallSuffix/ValueArguments/ValueArgument//LineStringContent/T-LineStrRef[
       @Text = ancestor::ClassDeclaration//PropertyDeclaration[T-VAR]//SimpleIdentifier/T-Identifier/concat('$', @Text)])
    (: not param in String concatenation of class var field :)
    and not(../../../../PostfixUnaryExpression//CallSuffix/ValueArguments/ValueArgument[//LineStringLiteral]//AdditiveExpression/MultiplicativeExpression//SimpleIdentifier/T-Identifier[
       @Text = ancestor::ClassDeclaration//PropertyDeclaration[T-VAR]//SimpleIdentifier/T-Identifier/@Text])
]

|

//FunctionDeclaration//PostfixUnaryExpression/PostfixUnarySuffix/NavigationSuffix/SimpleIdentifier/T-Identifier[
    @Text='toRegex'
    (: not called on function parameter :)
    and not(../../../../PrimaryExpression//T-Identifier[
        @Text = ancestor::FunctionDeclaration//FunctionValueParameter//Parameter/SimpleIdentifier/T-Identifier/@Text])
    (: not called on 'dynamic' function call :)
    and not(ancestor::PostfixUnaryExpression/PostfixUnarySuffix[1]/CallSuffix)
    (: not if based on local variable initialized by fun parameter :)
    and not(../../../../../PostfixUnaryExpression/PrimaryExpression/SimpleIdentifier/T-Identifier[
        @Text = ancestor::FunctionBody//PropertyDeclaration/VariableDeclaration/SimpleIdentifier/T-Identifier/@Text])
]

|

(: check if java.util.regex.Pattern import exists as filter for same named classes in other packages :)
//ImportHeader[
    (.//T-Identifier[@Text='java'] and .//T-Identifier[@Text='util'] and .//T-Identifier[@Text='regex'] and .//T-Identifier[@Text='Pattern'] or .//T-MULT)
  ][1]/ancestor::KotlinFile
//SimpleIdentifier/T-Identifier[@Text='Pattern'
    and ../../../PostfixUnarySuffix//T-Identifier[@Text='matches']
    (: not if first param is fun parameter :)
    and not(../../../PostfixUnarySuffix/CallSuffix/ValueArguments/ValueArgument[1]//SimpleIdentifier/T-Identifier[
        @Text = ancestor::FunctionDeclaration//Parameter/SimpleIdentifier/T-Identifier/@Text])
]

|

(: check if java.nio.file.FileSystems or java.nio.file.Path imports exists as filter for same named classes in other packages :)
(: TODO is this a bug: having to use T-FILE for 'file' :)
//ImportHeader[
    (.//T-Identifier[@Text='java']
        and .//T-Identifier[@Text='nio'] and .//T-FILE[@Text='file'] and .//T-Identifier[@Text='FileSystems' or @Text='Path'] or .//T-MULT)
  ][1]/ancestor::KotlinFile
(: added [ancestor::NavigationSuffix] to avoid PAT_STRING param from being selected too :)
//FunctionDeclaration//PostfixUnarySuffix//T-Identifier[ancestor::NavigationSuffix][@Text='getPathMatcher'
    and (ancestor::PostfixUnaryExpression/PrimaryExpression//T-Identifier[@Text=
              ancestor::Statement/preceding-sibling::Statement//VariableDeclaration[../Expression//T-Identifier[@Text='FileSystems']]//T-Identifier/@Text]
         or ancestor::PostfixUnaryExpression/PrimaryExpression/SimpleIdentifier/T-Identifier[@Text='FileSystems']

    )
    (: not if first param is fun parameter :)
    and not(ancestor::PrefixUnaryExpression//CallSuffix/ValueArguments/ValueArgument//SimpleIdentifier/T-Identifier[
       @Text = ancestor::FunctionDeclaration//Parameter/SimpleIdentifier/T-Identifier/@Text])
    (: not param in String template in fun parameter :)
    and not(ancestor::PrefixUnaryExpression//CallSuffix/ValueArguments/ValueArgument//LineStringContent/T-LineStrRef[
       @Text = ancestor::FunctionDeclaration//Parameter/SimpleIdentifier/T-Identifier/concat('$', @Text)])
]
                ]]></value>
            </property>
        </properties>
        <example>
class Foo {

    companion object {
        val INNER_LINE_BREAK_REGEX = """([^.\n])\n""".toRegex()
        val INNER_LINE_BREAK_PATTERN = """([^.\n])\n""".toPattern()
    }

    fun bad_replaceInnerLineBreakBySpace(text: String): String {
        return text.replace("""([^.\n])\n""".toRegex(), "$1 ") // bad
    }

    fun good_replaceInnerLineBreakBySpace1(text: String): String {
        return text.replace(INNER_LINE_BREAK_REGEX, "$1 ") // good
    }

    fun good_replaceInnerLineBreakBySpace2(text: String): String {
        return INNER_LINE_BREAK_PATTERN.matcher(text).replaceAll("$1 ") // good
    }

    fun storeUsingRegex(regex: String, sourceName: String, dataTable: DataTable) {
        val dtm = dataTable.asMaps()
        val source = testContext.parameter(sourceName)
        val matches = Regex(regex).findAll(source.toString()).toList()
    }
}
        </example>
    </rule>

    <rule name="AvoidInMemoryStreamingDefaultConstructor"
          language="kotlin"
          message="The default capacity or smaller is used for ByteArrayOutputStream or StringWriter, it usually needs expensive expansions."
          class="net.sourceforge.pmd.lang.rule.xpath.XPathRule"
externalInfoUrl="https://github.com/jborgers/PMD-jPinpoint-rules/tree/pmd7/docs/JavaCodePerformance.md#isio01">
        <description>
            The default constructor of ByteArrayOutputStream creates a 32-byte initial capacity and for StringWriter 16 chars. Problem: Such a small buffer as capacity usually needs several expensive expansions.&#13;
            Solution: Pre-size the ByteArrayOutputStream or StringWriter with an initial capacity such that an expansion is not needed in most cases, typically much larger than 32, for instance, 4096.
            (jpinpoint-rules)
        (jpinpoint-rules)</description>
        <priority>2</priority>
        <properties>
            <property name="tag" value="jpinpoint-rule" type="String" description="for-sonar"/>
            <property name="xpath">
                <value><![CDATA[
//ImportHeader[.//T-Identifier[@Text='java'] and .//T-Identifier[@Text='io']][1]/ancestor::KotlinFile
//Expression//T-Identifier[(@Text='ByteArrayOutputStream' and ../../../
PostfixUnarySuffix[1]//ValueArguments[not(ValueArgument) or ValueArgument//T-IntegerLiteral[number(@Text)<=32]])
or (@Text='StringWriter' and ../../../
PostfixUnarySuffix[1]//ValueArguments[not(ValueArgument) or ValueArgument//T-IntegerLiteral[number(@Text)<=16]])]
]]>
                </value>
            </property>
        </properties>
        <example><![CDATA[
import java.io.ByteArrayOutputStream
import java.io.StringWriter

class AvoidInMemoryStreamingDefaultConstructor {
    fun bad() {
        var baos = ByteArrayOutputStream() //bad
        val sw = StringWriter() //bad
        baos = ByteArrayOutputStream(32) //bad - not larger than default
    }
    fun good() {
        val baos = ByteArrayOutputStream(8192) // 8 kiB
        val sw = StringWriter(2048)
    }
}
]]>
        </example>
    </rule>

    <rule name="AvoidMultipleConcatStatements" class="net.sourceforge.pmd.lang.rule.xpath.XPathRule" language="kotlin" message="Multiple statements concatenate to the same String. Use StringBuilder append." externalInfoUrl="https://github.com/jborgers/PMD-jPinpoint-rules/tree/pmd7/docs/JavaCodePerformance.md#isu02">
        <description>Multiple statements concatenate to the same String. Problem: Each statement with one or more +-operators creates a hidden temporary StringBuilder, a char[] and a new String object, which all have to be garbage collected.&#13;
            Solution: Use StringBuilder.append.
            (jpinpoint-rules)</description>
        <priority>2</priority>
        <properties>
            <property name="tag" value="jpinpoint-rule" type="String" description="for-sonar"/>
            <property name="xpath">
                <value><![CDATA[
//FunctionBody[
  not(ancestor::FunctionDeclaration/SimpleIdentifier/T-Identifier[@Text='hashCode'])
  and
  count(
    .//Assignment[
      .//(AssignmentAndOperator/T-ADD_ASSIGNMENT|AdditiveOperator/T-ADD)
      and
      (AssignableExpression|DirectlyAssignableExpression)//T-Identifier[
        (: property a string literal :)
        @Text = ancestor::FunctionBody//PropertyDeclaration[
          (
            Expression[not(.//Expression)]//StringLiteral
            (: explicit type String:)
            or VariableDeclaration/Type//T-Identifier[@Text='String']
            (: assigned parameter of type String :)
            or Expression[.//T-Identifier[@Text = ancestor::FunctionDeclaration/FunctionValueParameters/FunctionValueParameter[Parameter/Type//T-Identifier[@Text='String']]//T-Identifier/@Text]]
            (: assigned non-nested function of explicit type String :) (: known issue: ignores parameters, may give false positives with overloaded methods :)
            or Expression[.//T-Identifier[not(ancestor::CallSuffix)][@Text = ancestor::ClassMemberDeclarations//FunctionDeclaration[Type//T-Identifier[@Text='String']]//T-Identifier/@Text]]
          )
          and not(Expression//T-Identifier[@Text='toMutableList'])
        ]/VariableDeclaration//T-Identifier/@Text
      ]
    ]
  ) > 1
]
//Statement[Assignment//(T-ADD_ASSIGNMENT|T-ADD)][position()=last()]
                ]]></value>
            </property>
        </properties>
        <example>

        </example>

    </rule>

    <rule name="AvoidRecompilingPatterns"
          class="net.sourceforge.pmd.lang.rule.xpath.XPathRule"
          language="kotlin"
          message="Pattern.compile is used in a method. Compiling a regex pattern can be expensive, make it a constant or instance field."
          externalInfoUrl="https://github.com/jborgers/PMD-jPinpoint-rules/tree/pmd7/docs/JavaCodePerformance.md#ireu02">
        <description>A regular expression is compiled on every invocation. Problem: this can be expensive, depending on the length of the regular expression.&#13;
            Solution: Usually a pattern is a literal, not dynamic and can be compiled only once. Assign it to a private constant or instance field.
            java.util.Pattern objects are thread-safe so they can be shared among threads. (jpinpoint-rules)</description>
        <priority>2</priority>
        <properties>
            <property name="tag" value="jpinpoint-rule" type="String" description="for-sonar"/>
            <property name="xpath">
                <value><![CDATA[
(: check if java.util.regex imports exists as filter for same named classes in other packages :)
//ImportHeader[.//T-Identifier[@Text='java'] and .//T-Identifier[@Text='util'] and .//T-Identifier[@Text='regex']][1]/ancestor::KotlinFile

//FunctionBody//T-Identifier[@Text='Pattern' and ../../../PostfixUnarySuffix//T-Identifier[@Text='compile']
(: check for variables $action or ${action} in String of compile() call (first in possible call chain): allow dynamic input :)
and not(
  let $params := ancestor::FunctionDeclaration//FunctionValueParameter/Parameter/SimpleIdentifier/T-Identifier/@Text
  return
    ((../../..//ValueArgument)[1]//PostfixUnaryExpression//T-Identifier | (../../..//ValueArgument)[1]//T-LineStrRef)[
      @Text = $params
      or (some $x in $params satisfies @Text = concat('$', $x))
    ]
)
]
]]>
                </value>
            </property>
        </properties>
        <example>
            <![CDATA[
import java.util.regex.Pattern

internal object Bad {
    const val STR_PAT1: String = "[A-Z][a-z]+"

    fun bad() {
        val p1: Pattern = Pattern.compile(STR_PAT1) // bad
        val p2: Pattern = Pattern.compile("(?=\\p{Lu})") // bad
        val b: Boolean = p1.matcher("Start ").matches()
    }
}

internal object Good {
    val PAT1: Pattern = Pattern.compile("[A-Z][a-z]+")
    val PAT2: Pattern = Pattern.compile("(?=\\p{Lu})")

    fun good() {
        val b: Boolean = PAT1.matcher("Start ").matches()
    }
}
            ]]>
        </example>
    </rule>

    <rule name="AvoidRecompilingXPathExpression" class="net.sourceforge.pmd.lang.rule.xpath.XPathRule"
          language="kotlin"
          message="XPathExpression is created and compiled every time. Beware it is thread-unsafe."
          externalInfoUrl="https://github.com/jborgers/PMD-jPinpoint-rules/tree/pmd7/docs/JavaCodePerformance.md#ux02">
        <description>XPathExpression is created and compiled on every method call, compiled possibly implicitly by XPath::evaluate.
            Problem: Creation of XPath and compilation of XPathExpression takes time. It may slow down your application. &#13;
            Solution:
            1. Avoid XPath usage.
            2. Compile the xpath expression as String into a XPathExpression. However, since XPath and XPathExpression classes are thread-unsafe, they are not easily cached. Caching it in a ThreadLocal may be a solution.
            (jpinpoint-rules)</description>
        <priority>2</priority>
        <properties>
            <property name="tag" value="jpinpoint-rule" type="String" description="for-sonar"/>
            <property name="xpath">
                <value><![CDATA[
//ImportHeader[.//T-Identifier[@Text='javax'] and .//T-Identifier[@Text='xml'] and .//T-Identifier[@Text='xpath']]/ancestor::KotlinFile
//FunctionBody//T-Identifier[@Text='newXPath']
/ancestor::FunctionBody//T-Identifier[@Text='compile'
or (@Text='evaluate' and ancestor::PostfixUnarySuffix/..//ValueArguments[count(./ValueArgument) = 3])]
(: note on limitation, the 2-argument version is not found, difficult to do the typeIs checking like in Java :)
]]></value>
            </property>
        </properties>
        <example>
            <![CDATA[
import org.w3c.dom.Document
import org.w3c.dom.NodeList
import javax.xml.xpath.*

class AvoidRecompilingXPathExpressionKotlin {
    fun bad1(doc: Document?): NodeList {
        val xpath: XPath = XPathFactory.newInstance().newXPath()
        val expr: XPathExpression = xpath.compile("//book[author='Isaac Asimov']/title/text()") // bad
        return expr.evaluate(doc, XPathConstants.NODESET) as NodeList
    }

    @Throws(XPathExpressionException::class)
    fun bad2(doc: Document?): NodeList {
        val xpath: XPath = XPathFactory.newInstance().newXPath()
        val xPathQuery = "//book[author='Isaac Asimov']/title/text()"
        return xpath.evaluate(xPathQuery, doc, XPathConstants.NODESET) as NodeList // bad
    }
}

object GoodAvoidRecompilingXPathExpressionKt {
    private val tlFac = ThreadLocal.withInitial { XPathFactory.newInstance() }
    private val tlExpr: ThreadLocal<XPathExpression>

    init {
        val xpath = tlFac.get().newXPath()
        val expr: XPathExpression = try {
            xpath.compile("//book[author='Isaac Asimov']/title/text()")
        } catch (e: XPathExpressionException) {
            throw RuntimeException(e)
        }
        tlExpr = ThreadLocal.withInitial { expr } // good
    }

    @Throws(XPathExpressionException::class)
    fun good(doc: Document?): NodeList {
        return tlExpr!!.get().evaluate(doc, XPathConstants.NODESET) as NodeList // good
    }
}
            ]]>
        </example>
    </rule>

    <rule name="AvoidRecreatingDateTimeFormatter"
          message="Avoid recreating DateTimeFormatter, it is relatively expensive."
          class="net.sourceforge.pmd.lang.rule.xpath.XPathRule" language="kotlin"
          externalInfoUrl="https://github.com/jborgers/PMD-jPinpoint-rules/tree/master/docs/JavaCodePerformance.md#idtf02">
        <description>
            Problem: Recreating a DateTimeFormatter is relatively expensive.&#13;
            Solution: org.joda.time.format.DateTimeFormatter or Java 8 java.time.DateTimeFormatter is thread-safe and can be shared among threads. Create the
            formatter from a pattern only once, to initialize a constant or instance field.
            (jpinpoint-rules)</description>
        <priority>2</priority>
        <properties>
            <property name="tag" value="jpinpoint-rule" type="String" description="for-sonar"/>
            <property name="xpath">
                <value>
                    <![CDATA[
(: check if java.time.format or org.joda.time.format imports exists as filter for same named classes in other packages :)
//ImportHeader[
    (.//T-Identifier[@Text='org'] and .//T-Identifier[@Text='joda'] and .//T-Identifier[@Text='time'] and .//T-Identifier[@Text='format'])
    or (.//T-Identifier[@Text='java'] and .//T-Identifier[@Text='time'] and .//T-Identifier[@Text='format'])
  ][1]/ancestor::KotlinFile

/TopLevelObject//Expression//T-Identifier[
    (@Text='DateTimeFormatter' or @Text='DateTimeFormat' or @Text='DateTimeFormatterBuilder' or @Text='ISODateTimeFormat')
     (: val is "final" and is allowed in CompanionObject :)
     and (not(ancestor::PropertyDeclaration/T-VAL) or (ancestor::PropertyDeclaration/T-VAL and not(ancestor::CompanionObject)))
     (: and 'final static' is allowed, top level, field outside of class/object :)
     and (ancestor::ClassDeclaration or ancestor::ObjectDeclaration)
     (: do not match explicit type declarations :)
     and not(ancestor::TypeReference)
     (: variable params are allowed, e.g. when it is an incoming function param :)
     and not(ancestor::PrefixUnaryExpression//ValueArgument[.//T-Identifier[@Text = ancestor::FunctionDeclaration/FunctionValueParameters/FunctionValueParameter/Parameter/SimpleIdentifier/T-Identifier/@Text]])
     (: variable class params are allowed in val fields :)
     and (not(ancestor::PropertyDeclaration/T-VAL) or not(ancestor::PrefixUnaryExpression//ValueArgument[.//T-Identifier[@Text = ancestor::ClassDeclaration//ClassParameters/ClassParameter/SimpleIdentifier/T-Identifier/@Text]])
     (: not when like DateTimeFormatter.ISO_DATE_TIME :)
     and (not(ancestor::PostfixUnaryExpression[count(PostfixUnarySuffix) = 1]))
    )
]
|
(: java.time.format.DateTimeFormatter variable params are allowed in field init in constructors if val :)
//ImportHeader[
    .//T-Identifier[@Text='java'] and .//T-Identifier[@Text='time'] and .//T-Identifier[@Text='format']
  ][1]/ancestor::KotlinFile

/TopLevelObject//Expression//T-Identifier[
    @Text='DateTimeFormatter'
     (: check if variable function params in init constructor with two params :)
     and ancestor::PostfixUnaryExpression/PostfixUnarySuffix//ValueArguments[
           count(ValueArgument) = 2
           and count(./ValueArgument//T-Identifier[@Text = ancestor::FunctionDeclaration/FunctionValueParameters/FunctionValueParameter/Parameter/SimpleIdentifier/T-Identifier/@Text]) = 2
           (: check if variable is a var :)
           and ancestor::Statement/Assignment//T-Identifier[@Text = ancestor::ClassBody//VariableDeclaration//T-Identifier[ancestor::PropertyDeclaration/T-VAR]/@Text]
     ]
]
]]>
                </value>
            </property>
        </properties>
        <example>
            <![CDATA[
class Bad {
    public String formatDate(LocalDateTime date)  {
        DateTimeFormatter dtf =  new DateTimeFormatterBuilder().toFormatter(); // bad, created each time
        return dtf.format(date);
    }
}

class Good {
    private static final DateTimeFormatter DTF = new DateTimeFormatterBuilder().toFormatter();

    public String formatDate(LocalDateTime date)  {
        return DTF.format(date); // good, reuse thread-safe formatter
    }
}
            ]]>
        </example>
    </rule>

    <rule name="AvoidSimpleDateFormat"
          class="net.sourceforge.pmd.lang.rule.xpath.XPathRule"
          language="kotlin"
          message="SimpleDateFormat is used. Since it is thread-unsafe, it needs expensive recreation."
          externalInfoUrl="https://github.com/jborgers/PMD-jPinpoint-rules/tree/pmd7/docs/JavaCodePerformance.md#idtf01">
        <description>Problem: java.util.SimpleDateFormat is thread-unsafe. The usual solution is to create a new one when needed in a method. Creating SimpleDateFormat is relatively expensive. &#13;
            Solution: Use java.time.DateTimeFormatter. These classes are immutable, thus thread-safe and can be made static.
            (jpinpoint-rules)</description>
        <priority>2</priority>
        <properties>
            <property name="tag" value="jpinpoint-rule" type="String" description="for-sonar"/>
            <property name="xpath">
                <value><![CDATA[
(: check if java.text imports exists as filter for same named classes in other packages :)
//ImportHeader[.//T-Identifier[@Text='java'] and .//T-Identifier[@Text='text']][1]/../..

(: if used in setDateFormat function, allow if jackson ObjectMapper or XmlMapper is used :)
//ClassMemberDeclaration//SimpleIdentifier//T-Identifier[(@Text="SimpleDateFormat")
  and not (ancestor::ClassMemberDeclaration//T-Identifier[@Text="setDateFormat"]
              and //ImportHeader[.//T-Identifier[@Text='fasterxml'] and .//T-Identifier[@Text='jackson']]
          )
]
                ]]></value>
            </property>
        </properties>
        <example><![CDATA[
import java.text.SimpleDateFormat
import java.util.*

class Foo {
    private fun toKey(calcDate: Date): String {
        val formatter = SimpleDateFormat("yyyy-MM-dd") //bad
        return formatter.format(calcDate)
    }
}
]]>
        </example>
    </rule>

    <rule name="AvoidStringBuffer" class="net.sourceforge.pmd.lang.rule.xpath.XPathRule"
          language="kotlin"
          message="StringBuffer is used. It introduces locking overhead, use StringBuilder."
          externalInfoUrl="https://github.com/jborgers/PMD-jPinpoint-rules/tree/pmd7/docs/JavaCodePerformance.md#isu01" >
        <description>Problem: StringBuffer introduces locking overhead because it is thread safe. Its thread-safety is rarely needed.&#13;
            Solution: Replace StringBuffer by StringBuilder.  (jpinpoint-rules)</description>
        <priority>3</priority>
        <properties>
            <property name="tag" value="jpinpoint-rule" type="String" description="for-sonar"/>
            <property name="xpath">
                <value><![CDATA[
//VariableDeclaration/Type//T-Identifier[@Text='StringBuffer'],
//Declaration//PrimaryExpression//T-Identifier[@Text='StringBuffer']
]]>
                </value>
            </property>
        </properties>
        <example>
            <![CDATA[
class AvoidStringBuffer {
    var fieldSb: StringBuffer? = null // bad
    fun bad() {
        val sb = StringBuffer() // bad
    }
    fun good() {
        val sb = StringBuilder()
    }
]]>
        </example>
    </rule>

    <rule name="AvoidWideScopeXPathExpression"
          class="net.sourceforge.pmd.lang.rule.xpath.XPathRule"
          language="kotlin"
          message="XPathExpression targets a wide scope, this is potentially slow."
          externalInfoUrl="https://github.com/jborgers/PMD-jPinpoint-rules/tree/pmd7/docs/JavaCodePerformance.md#ux01">
        <description>The XPathExpression targets a wide scope since it starts with `//`. Problem: XPath has to search in a wide scope for occurrences, this may take a while. &#13;
            Solution:
            1. Avoid XPath usage.
            2. Make the scope as narrow as possible, do not start with `//`.
            (jpinpoint-rules)</description>
        <priority>2</priority>
        <properties>
            <property name="tag" value="jpinpoint-rule" type="String" description="for-sonar"/>
            <property name="xpath">
                <value><![CDATA[
(: check if javax.xml.xpath imports exists as filter for same named classes in other packages :)
//ImportHeader[.//T-Identifier[@Text='javax'] and .//T-Identifier[@Text='xml'] and .//T-Identifier[@Text='xpath']][1]/../..

(: if 'compile' method exists with one parameter of String literal with first chars '//' :)
//ClassMemberDeclaration//SimpleIdentifier//T-Identifier[(@Text="compile")
  and ancestor::Expression//ValueArguments[count(./ValueArgument) = 1]/ValueArgument//PrimaryExpression/StringLiteral//T-LineStrText[starts-with(@Text, '//')]
]
	]]></value>
            </property>
        </properties>
        <example><![CDATA[
import org.w3c.dom.Node
import javax.xml.xpath.XPath
import javax.xml.xpath.XPathFactory

class Foo {

    var xpath: XPath = XPathFactory.newInstance().newXPath()

    fun parseSomething(books: Node) {
        val expr = xpath
            .compile("//book[author='Isaac Asimov']/title/text()") // bad
        val result = expr.evaluate(books)
    }
}
]]>
        </example>
    </rule>

    <rule name="AvoidXPathAPIUsage"
          class="net.sourceforge.pmd.lang.rule.xpath.XPathRule"
          language="kotlin"
          message="XPathAPI is used. XPathAPI implementation has bad performance."
          externalInfoUrl="https://github.com/jborgers/PMD-jPinpoint-rules/tree/pmd7/docs/JavaCodePerformance.md#ux01">
        <description>XPathAPI is used. Problem: XPathAPI implementation is slow.&#13;
            Solution:
            1. try to avoid using XPathAPI.
            2. improve performance by using jvm parameters and possibly CachedXPathAPI.
            (jpinpoint-rules)</description>
        <priority>2</priority>
        <properties>
            <property name="tag" value="jpinpoint-rule" type="String" description="for-sonar"/>
            <!--property name="tag" value="performance" type="String" description="for-sonar"/-->
            <property name="xpath">
                <value><![CDATA[
//ImportHeader[.//T-Identifier[@Text='org'] and .//T-Identifier[@Text='apache'] and .//T-Identifier[@Text='xpath']][1]/ancestor::KotlinFile
//ClassBody//SimpleIdentifier/T-Identifier[@Text='XPathAPI']
	]]></value>
            </property>
        </properties>
        <example><![CDATA[
import org.w3c.dom.Node
import org.apache.xpath.XPathAPI
import org.apache.xpath.CachedXPathAPI

class FooBad {
    fun getAction(doc: Node?): String? {
        return try {
            XPathAPI.eval(doc, "/Envelope/Header/Action").toString() // bad
        } catch (e: TransformerException) {
            null
        }
    }
}

class FooGood {
    fun getAction(doc: Node?): String? {
        return try {
            CachedXPathAPI.eval(doc, "/Envelope/Header/Action").toString()
        } catch (e: TransformerException) {
            null
        }
    }
}
]]>
        </example>
    </rule>

    <rule name="MDCPutWithoutRemove"
          class="net.sourceforge.pmd.lang.rule.xpath.XPathRule"
          language="kotlin"
          message="MDC put is used without remove or clear in the same function"
          externalInfoUrl="https://github.com/jborgers/PMD-jPinpoint-rules/tree/pmd7/docs/JavaCodePerformance.md#IL04">
        <description>
            MDC values are added for logging, but no corresponding remove or clear is performed. Problem: MDC values can leak to other user transactions (requests) and log incorrect information. Solution: remove the MDC value in a finally clause or clear the MDC.
            (jpinpoint-rules - Kotlin)
        (jpinpoint-rules)</description>
        <priority>2</priority>
        <properties>
            <property name="tag" value="jpinpoint-rule" type="String" description="for-sonar"/>
            <property name="xpath">
                <value><![CDATA[
(: Only consider files that import org.slf4j.MDC :)
//ImportHeader[.//T-Identifier[@Text='org'] and .//T-Identifier[@Text='slf4j'] and .//T-Identifier[@Text='MDC']][1]/ancestor::KotlinFile

(: Select calls to MDC.put(..) :)
//PostfixUnaryExpression[
  PrimaryExpression/SimpleIdentifier/T-Identifier[@Text='MDC']
  and PostfixUnarySuffix/NavigationSuffix/SimpleIdentifier/T-Identifier[@Text='put']
]
(: Report the 'put' identifier if there is no MDC.remove(..) or MDC.clear() in same function, nor via a method called from a finally block (Issue #653) :)
/PostfixUnarySuffix/NavigationSuffix/SimpleIdentifier/T-Identifier[@Text='put'
  and not(
      (: same function body has direct MDC.remove/clear :)
      ancestor::FunctionBody//PostfixUnaryExpression[
          PrimaryExpression/SimpleIdentifier/T-Identifier[@Text='MDC']
          and PostfixUnarySuffix/NavigationSuffix/SimpleIdentifier/T-Identifier[@Text=('remove','clear')]
      ]
      or
      (
        (: put-arg text equals any remove-arg text inside a helper method that is called from a finally block in this class :)
        ancestor::ClassDeclaration
          //FunctionDeclaration[
            SimpleIdentifier/T-Identifier/@Text = ancestor::ClassDeclaration//TryExpression//FinallySection//PostfixUnaryExpression[PostfixUnarySuffix/CallSuffix]//PrimaryExpression/SimpleIdentifier/T-Identifier/@Text
          ]
          //PostfixUnaryExpression[
            PrimaryExpression/SimpleIdentifier/T-Identifier[@Text='MDC']
            and PostfixUnarySuffix/NavigationSuffix/SimpleIdentifier/T-Identifier[@Text='remove']
          ]/PostfixUnarySuffix/CallSuffix/ValueArguments/ValueArgument[1]//(SimpleIdentifier/T-Identifier|LineStringLiteral//T-LineStrText)/@Text
        =
        ancestor::PostfixUnaryExpression/PostfixUnarySuffix/CallSuffix/ValueArguments/ValueArgument[1]//(SimpleIdentifier/T-Identifier|LineStringLiteral//T-LineStrText)/@Text
      )
      or
      (
        (: helper method called from finally does MDC.clear() :)
        ancestor::ClassDeclaration
          //FunctionDeclaration[
            SimpleIdentifier/T-Identifier/@Text = ancestor::ClassDeclaration//TryExpression//FinallySection//PostfixUnaryExpression/PostfixUnarySuffix/NavigationSuffix/SimpleIdentifier/T-Identifier/@Text
          ]
          //PostfixUnaryExpression[
            PrimaryExpression/SimpleIdentifier/T-Identifier[@Text='MDC']
            and PostfixUnarySuffix/NavigationSuffix/SimpleIdentifier/T-Identifier[@Text='clear']
          ]
      )
      or
      (
        (: looser, anywhere in class: a remove of same key exists :)
        ancestor::ClassDeclaration//PostfixUnaryExpression[
           PrimaryExpression/SimpleIdentifier/T-Identifier[@Text='MDC']
           and PostfixUnarySuffix/NavigationSuffix/SimpleIdentifier/T-Identifier[@Text='remove']
        ]/PostfixUnarySuffix/CallSuffix/ValueArguments/ValueArgument[1]//(SimpleIdentifier/T-Identifier|LineStringLiteral//T-LineStrText)/@Text
        =
        ancestor::PostfixUnaryExpression/PostfixUnarySuffix/CallSuffix/ValueArguments/ValueArgument[1]//(SimpleIdentifier/T-Identifier|LineStringLiteral//T-LineStrText)/@Text
      )
      or
      (
        (: looser, anywhere in class: a clear exists :)
        ancestor::ClassDeclaration//PostfixUnaryExpression[
           PrimaryExpression/SimpleIdentifier/T-Identifier[@Text='MDC']
           and PostfixUnarySuffix/NavigationSuffix/SimpleIdentifier/T-Identifier[@Text='clear']
        ]
      )
  )
]
]]></value>
            </property>
        </properties>
        <example><![CDATA[
import org.slf4j.MDC

class BadKotlinMdc {
    fun bad() {
        MDC.put("levelKey1", "levelName1") // bad, not removed or cleared
        MDC.put("levelKey2", "levelName2") // bad, not removed or cleared
    }
}

class GoodKotlinMdc {
    fun good() {
        try {
            MDC.put("levelKey1", "levelName1")
            MDC.put("levelKey2", "levelName2")
        } finally {
            MDC.clear()
        }
    }
}
        ]]></example>
    </rule>

<!-- END Included file 'common.xml' -->
<!-- BEGIN Included file 'remoting.xml' -->
    <rule name="AvoidDeprecatedHystrix"
          language="kotlin"
          class="net.sourceforge.pmd.lang.rule.xpath.XPathRule"
          message="Netflix Hystrix is deprecated. Use an alternative like resilience4j"
          externalInfoUrl="https://github.com/jborgers/PMD-jPinpoint-rules/tree/pmd7/docs/JavaCodePerformance.md#ibi11">
        <description>Problem: Hystrix is not actively maintained anymore.&#13;
            Solution: Netflix recommends to use open source alternatives like resilience4j. (jpinpoint-rules)</description>
        <priority>3</priority>
        <properties>
            <property name="tag" value="jpinpoint-rule" type="String" description="for-sonar"/>
            <property name="xpath">
                <value><![CDATA[
(: check if javax.xml.xpath imports exists as filter for same named classes in other packages :)
//ImportHeader[.//T-Identifier[@Text='com'] and .//T-Identifier[@Text='netflix'] and .//T-Identifier[@Text='hystrix']][1]/../..
]]>
                </value>
            </property>
        </properties>
        <example>
        </example>
    </rule>

    <rule name="HttpClientBuilderWithoutDisableConnectionState"
          language="kotlin"
          message="A HttpClient builder is used and disableConnectionState is not called. HTTP client tracks connection state while using TLS."
          class="net.sourceforge.pmd.lang.rule.xpath.XPathRule"
          externalInfoUrl="https://github.com/jborgers/PMD-jPinpoint-rules/tree/pmd7/docs/JavaCodePerformance.md#ibi07">
        <description>
            Problem: NTLM authenticated connections and SSL/TLS connections with client certificate authentication are stateful: they have a specific user identity/security context per session. If HttpClients have enabled connection state tracking which is the default, established TLS connections will not be reused because it is assumed that the user identity or security context may differ.
            Then performance will suffer due to a full TLS handshake for each request.&#13;
            Solution: HttpClients should disable connection state tracking in order to reuse TLS connections, since service calls for one pool have the same user identity/security context for all sessions. (jpinpoint-rules)
        (jpinpoint-rules)</description>
        <priority>2</priority>
        <properties>
            <property name="tag" value="jpinpoint-rule" type="String" description="for-sonar"/>
            <property name="xpath">
                <value><![CDATA[
(:locally created http client builder without disableConnectionState :)
//PostfixUnarySuffix//SimpleIdentifier/T-Identifier[@Text="custom"
  and ancestor::PostfixUnaryExpression/PrimaryExpression/SimpleIdentifier/T-Identifier/@Text="HttpClients"
  and not(ancestor::PostfixUnaryExpression/PostfixUnarySuffix/NavigationSuffix/SimpleIdentifier/T-Identifier/@Text="disableConnectionState")]
,
//PostfixUnarySuffix//SimpleIdentifier/T-Identifier[@Text="create"
  and ancestor::PostfixUnaryExpression/PrimaryExpression/SimpleIdentifier/T-Identifier[(@Text="HttpClientBuilder" or @Text="HttpAsyncClientBuilder")
  and not(ancestor::PostfixUnaryExpression/PostfixUnarySuffix/NavigationSuffix/SimpleIdentifier/T-Identifier/@Text="disableConnectionState")]]
,
(: method param http client builder without disableConnectionState :)
//FunctionValueParameter/Parameter/Type/TypeReference/UserType/SimpleUserType/SimpleIdentifier/T-Identifier[(@Text="HttpClients" or @Text="HttpClientBuilder" or @Text="HttpAsyncClientBuilder")
  and not(ancestor::FunctionDeclaration//PostfixUnarySuffix/NavigationSuffix/SimpleIdentifier/T-Identifier/@Text="disableConnectionState")]
]]>
                </value>
            </property>
        </properties>
        <example><![CDATA[
    private fun createHttpClientBuilder(properties: ConnectionProperties) =
        HttpClients.custom()
            .setDefaultRequestConfig(createRequestConfig(properties))
            .setMaxConnTotal(properties.maxConnTotal)
            .setMaxConnPerRoute(properties.maxConnPerRoute) // violation, no disableConnectionState() call
]]>
        </example>
    </rule>

    <rule name="HttpClientBuilderWithoutPoolSize"
          language="kotlin"
          message="HttpClient builder connection pool is not configured."
          class="net.sourceforge.pmd.lang.rule.xpath.XPathRule"
          externalInfoUrl="https://github.com/jborgers/PMD-jPinpoint-rules/tree/pmd7/docs/JavaCodePerformance.md#ibi03">
        <description>
            Problem: when the [default max connections per route] external calls are being made to the same host,
            the next thread requesting a connection to that host must wait for a free connection.
            For Apache HttpClient v4, this default = 2 and for v5 this default = 5, often too low.
            Max total connections are 20 and 25 respectively.&#13;
            Solution: HttpClients should explicitly define the number of connections per route. If only one route is
            used, make the max number of connections equal to conn per route.
            Solution:
            1. use setConnectionManager and call setMaxTotal and setDefaultMaxPerRoute on that connection manager, or
            2. use no ConnectionManager, call setMaxConnTotal and setMaxConnPerRoute on the client directly (v4 only).
            (jpinpoint-rules)
        (jpinpoint-rules)</description>
        <priority>2</priority>
        <properties>
            <property name="tag" value="jpinpoint-rule" type="String" description="for-sonar"/>
            <property name="xpath">
                <value><![CDATA[
(: check if Apache HttpClient v4 or v5 imports exist to avoid name clashes :)
//ImportHeader[
  (.//T-Identifier[@Text='org'] and .//T-Identifier[@Text='apache'] and .//T-Identifier[@Text='http'])
  or
  (.//T-Identifier[@Text='org'] and .//T-Identifier[@Text='apache'] and .//T-Identifier[@Text='hc'] and .//T-Identifier[@Text='client5'])
][1]/ancestor::KotlinFile
//PostfixUnarySuffix//SimpleIdentifier/T-Identifier[
  @Text='custom' and ancestor::PostfixUnaryExpression/PrimaryExpression/SimpleIdentifier/T-Identifier/@Text='HttpClients'
][
  ancestor::FunctionDeclaration[
    not(.//SimpleIdentifier/T-Identifier[@Text='setConnectionManager'] or
        (.//SimpleIdentifier/T-Identifier[@Text='setMaxConnTotal'] and .//SimpleIdentifier/T-Identifier[@Text='setMaxConnPerRoute'])
    )
  ]
]
|
//ImportHeader[
  (.//T-Identifier[@Text='org'] and .//T-Identifier[@Text='apache'] and .//T-Identifier[@Text='http'])
  or
  (.//T-Identifier[@Text='org'] and .//T-Identifier[@Text='apache'] and .//T-Identifier[@Text='hc'] and .//T-Identifier[@Text='client5'])
][1]/ancestor::KotlinFile
//PostfixUnarySuffix//SimpleIdentifier/T-Identifier[
  @Text='create' and ancestor::PostfixUnaryExpression/PrimaryExpression/SimpleIdentifier/T-Identifier[@Text='HttpClientBuilder' or @Text='HttpAsyncClientBuilder']
][
  ancestor::FunctionDeclaration[
    not(.//SimpleIdentifier/T-Identifier[@Text='setConnectionManager'] or
        (.//SimpleIdentifier/T-Identifier[@Text='setMaxConnTotal'] and .//SimpleIdentifier/T-Identifier[@Text='setMaxConnPerRoute'])
    )
  ]
]
|
//ImportHeader[
  (.//T-Identifier[@Text='org'] and .//T-Identifier[@Text='apache'] and .//T-Identifier[@Text='http'])
  or
  (.//T-Identifier[@Text='org'] and .//T-Identifier[@Text='apache'] and .//T-Identifier[@Text='hc'] and .//T-Identifier[@Text='client5'])
][1]/ancestor::KotlinFile
//FunctionDeclaration//TypeReference//SimpleIdentifier/T-Identifier[@Text='PoolingHttpClientConnectionManager' or @Text='PoolingAsyncClientConnectionManager']
[
  ancestor::FunctionDeclaration[
    not(
      (.//SimpleIdentifier/T-Identifier[@Text='setMaxTotal'] and .//SimpleIdentifier/T-Identifier[@Text='setDefaultMaxPerRoute'])
      or (
        (.//SimpleIdentifier/T-Identifier[@Text='setMaxConnTotal'] and .//SimpleIdentifier/T-Identifier[@Text='setMaxConnPerRoute'])
        and .//SimpleIdentifier/T-Identifier[@Text='PoolingHttpClientConnectionManagerBuilder']
      )
    )
    and not(
      ancestor::ClassBody//FunctionDeclaration[
        (.//SimpleIdentifier/T-Identifier[@Text='setMaxTotal'] and .//SimpleIdentifier/T-Identifier[@Text='setDefaultMaxPerRoute'])
        or (
          (.//SimpleIdentifier/T-Identifier[@Text='setMaxConnTotal'] and .//SimpleIdentifier/T-Identifier[@Text='setMaxConnPerRoute'])
          and .//SimpleIdentifier/T-Identifier[@Text='PoolingHttpClientConnectionManagerBuilder']
        )
      ]
    )
  ]
]
                ]]></value>
            </property>
        </properties>
        <example><![CDATA[
fun bad(conMgr: Any?): HttpClient =
    HttpClientBuilder.create() // bad, missing setMaxConnPerRoute/setMaxConnTotal or setConnectionManager
        .build()

fun goodWithMgr(conMgr: Any?): HttpClient =
    HttpClientBuilder.create()
        .setConnectionManager(conMgr) // good, delegated to manager
        .build()

fun goodWithSizes(): HttpClient =
    HttpClients.custom()
        .setMaxConnPerRoute(MAX_CONNECTIONS)
        .setMaxConnTotal(MAX_CONNECTIONS)
        .build()
]]></example>
    </rule>

    <rule name="HttpClientBuilderWithoutTimeouts"
          class="net.sourceforge.pmd.lang.rule.xpath.XPathRule"
          language="kotlin"
          message="Apache HttpClient builder is used and not all three timeouts are configured."
          externalInfoUrl="https://github.com/jborgers/PMD-jPinpoint-rules/tree/pmd7/docs/JavaCodePerformance.md#IBI10">
        <description>Problem: for connectionRequestTimeout, connectTimeout, socketTimeout (using
            HttpComponentsClientHttpRequestFactory/RequestConfig) or readTimeout/responseTimeout (using RequestConfig v4/v5) and connectTimeout (using ConnectionConfig v5)
            the default timeout settings are not optimal in most cases. &#13;
            Solution: Set the timeouts explicitly to proper reasoned values. See best practice values via the link. Use
            the setDefaultRequestConfig with a method with a RequestConfig object on HttpClient builders to set the
            timeouts. (jpinpoint-rules)
        (jpinpoint-rules)</description>
        <priority>2</priority>
        <properties>
            <property name="tags" value="io,jpinpoint-rule,performance,pitfall,resilience" type="String" description="classification"/>
            <property name="xpath">
                <value><![CDATA[
(: v4/v5 builders without setDefaultRequestConfig :)
//PostfixUnarySuffix//SimpleIdentifier/T-Identifier[@Text="create"
  and ancestor::PostfixUnaryExpression/PrimaryExpression/SimpleIdentifier/T-Identifier/@Text="HttpClientBuilder"
  and not(ancestor::PostfixUnaryExpression/PostfixUnarySuffix/NavigationSuffix/SimpleIdentifier/T-Identifier/@Text="setDefaultRequestConfig")]
,
//PostfixUnarySuffix//SimpleIdentifier/T-Identifier[@Text="create"
  and ancestor::PostfixUnaryExpression/PrimaryExpression/SimpleIdentifier/T-Identifier/@Text="HttpAsyncClientBuilder"
  and not(ancestor::PostfixUnaryExpression/PostfixUnarySuffix/NavigationSuffix/SimpleIdentifier/T-Identifier/@Text="setDefaultRequestConfig")]
,
//PostfixUnarySuffix//SimpleIdentifier/T-Identifier[@Text="custom"
  and ancestor::PostfixUnaryExpression/PrimaryExpression/SimpleIdentifier/T-Identifier/@Text="HttpClients"
  and not(ancestor::PostfixUnaryExpression/PostfixUnarySuffix/NavigationSuffix/SimpleIdentifier/T-Identifier/@Text="setDefaultRequestConfig")]
,
(: v4 RequestConfig missing at least one of the three timeouts:)
//ImportHeader[.//T-Identifier[@Text='org'] and .//T-Identifier[@Text='apache'] and .//T-Identifier[@Text='http'] and .//T-Identifier[@Text='client'] and .//T-Identifier[@Text='config'] and .//T-Identifier[@Text='RequestConfig']][1]/ancestor::KotlinFile
//PostfixUnarySuffix//SimpleIdentifier/T-Identifier[
  @Text="custom"
  and ancestor::PostfixUnaryExpression/PrimaryExpression/SimpleIdentifier/T-Identifier/@Text="RequestConfig"
  and not(
    count(ancestor::PostfixUnaryExpression/PostfixUnarySuffix/NavigationSuffix/SimpleIdentifier/T-Identifier[@Text=('setConnectionRequestTimeout','setConnectTimeout','setSocketTimeout')]/@Text) = 3
  )
]
,
(: v5 RequestConfig missing at least one of the two timeouts:)
//ImportHeader[.//T-Identifier[@Text='org'] and .//T-Identifier[@Text='apache'] and .//T-Identifier[@Text='hc'] and .//T-Identifier[@Text='client5'] and .//T-Identifier[@Text='http'] and .//T-Identifier[@Text='config'] and .//T-Identifier[@Text='RequestConfig']][1]/ancestor::KotlinFile
//PostfixUnarySuffix//SimpleIdentifier/T-Identifier[
  @Text="custom"
  and ancestor::PostfixUnaryExpression/PrimaryExpression/SimpleIdentifier/T-Identifier/@Text="RequestConfig"
  and not(
    ancestor::PostfixUnaryExpression/PostfixUnarySuffix/NavigationSuffix/SimpleIdentifier/T-Identifier/@Text="setConnectionRequestTimeout"
    and ancestor::PostfixUnaryExpression/PostfixUnarySuffix/NavigationSuffix/SimpleIdentifier/T-Identifier/@Text="setResponseTimeout"
  )
]
,
(: Spring HttpComponentsClientHttpRequestFactory missing full timeout configuration in a function :)
//SimpleIdentifier/T-Identifier[@Text='HttpComponentsClientHttpRequestFactory'
  and ancestor::FunctionDeclaration[
    count(.//SimpleIdentifier/T-Identifier[@Text=('setConnectTimeout', 'setConnectionRequestTimeout', 'setReadTimeout')]) < 3
  ]
]
]]>
                </value>
            </property>
        </properties>
        <example><![CDATA[
class BadHttpClientV5 {
    public HttpClient createClient() {
        RequestConfig requestConfig = RequestConfig.custom()
                .setResponseTimeout(Timeout.ofMilliseconds(1200))
                .build();

        return HttpClients.custom()
                .build();
    }
}

class GoodHttpClientV5 {
    public CloseableHttpClient createHttpClient() {
        ConnectionConfig connectionConfig = ConnectionConfig.custom()
                .setConnectTimeout(Timeout.ofMilliseconds(300))
                .build();

        PoolingHttpClientConnectionManager connectionManager =
                PoolingHttpClientConnectionManagerBuilder.create()
                        .setDefaultConnectionConfig(connectionConfig)
                        .build();

        RequestConfig requestConfig = RequestConfig.custom()
                .setConnectionRequestTimeout(Timeout.ofMilliseconds(100))
                .setResponseTimeout(Timeout.ofMilliseconds(1200))
                .build();

        return HttpClients.custom() // good, all expected overrides for timeouts
                .setDefaultRequestConfig(requestConfig)
                .setConnectionManager(connectionManager)
                .build();
    }
}
]]>
        </example>
    </rule>

    <rule name="NettyConnectionProviderWithoutMaxOrTimeout"
          message="Netty ConnectionProvider has no defined maxConnections or pendingAcquireTimeout."
          class="net.sourceforge.pmd.lang.rule.xpath.XPathRule"
          language="kotlin"
          externalInfoUrl="https://github.com/jborgers/PMD-jPinpoint-rules/tree/pmd7/docs/JavaCodePerformance.md#ibi26">
        <description>Problem: If a Reactor Netty Connection Provider is built without an explicit `maxConnections`, this defaults to `max(#CPU, 8) * 2`.
            This is often too low, leading to throttling, delays and too long response times.
            If the provider is built without an explicit `pendingAcquireTimeout`, this defaults to `45s`.
            This is often too high, leading to unnecessary long waiting times.
            Solution: Define both `maxConnections` and `pendingAcquireTimeout` with proper values, for instance, `50` and `300 [ms]` respectively.
            (jpinpoint-rules)
        (jpinpoint-rules)</description>
        <priority>1</priority>
        <properties>
            <property name="tags" value="io,jpinpoint-rule,performance,sustainability-low,resilience" type="String" description="classification"/>
            <property name="xpath">
                <value><![CDATA[
//ImportHeader[
  .//T-Identifier[@Text='reactor'] and .//T-Identifier[@Text='netty'] and .//T-Identifier[@Text='resources']
][1]/ancestor::KotlinFile
  //FunctionBody//Statement//T-Identifier[@Text='ConnectionProvider']/../../..//T-Identifier[@Text='builder']
    [not(ancestor::Statement//T-Identifier[@Text='maxConnections']) or not (ancestor::Statement//T-Identifier[@Text='pendingAcquireTimeout'])]
                ]]></value>
            </property>
        </properties>
        <example>
            <![CDATA[
fun connectionProviderBad(): ConnectionProvider {
    return ConnectionProvider.builder("myProvider").build() // bad
}
fun connectionProviderGood(): ConnectionProvider {
    return ConnectionProvider.builder("myProvider")
        .maxConnections(props.maxConnections)
        .pendingAcquireTimeout(props.pendingAcquireTimeoutMs)
        .build()
}
    ]]>
        </example>
    </rule>

<!-- END Included file 'remoting.xml' -->
</ruleset>