A modern programming language that makes developers happier.

kotlinlang

Hello there, we use the limit of 60 loc per method as a `Detekt` rule
```LongMethod:
    active: true
    threshold: 60```
but we find it too small for `@Composable` functions. Is there a way to exclude composables from this limit, something like `ignoreAnnotated` in `LongParameterList` ?

If you updates to the last RC (the stable version is near to be released) you can use `ignoreAnnotated` in that rule (or any other rule)

thx, I see its already in <https://github.com/detekt/detekt/releases/tag/v1.18.0|v1.18.0> :slightly_smiling_face:  I will upgrade

Just got released btw :slightly_smiling_face:

I don't usually face this issue. My `@Composable` methods are not longer than my non-composable ones

which threshold do you use? Maybe the configuration that I use is too strict

Same for me. 60 lines (default value). My composables shouldn't be bigger than other functions. 60 give me a lot of room.

&gt; Ideally I would like to have another threshold for for `LongMethod` but I do not know if that's possible
This is a know limition of the current detekt. There is no way to have the same rule with two different confirgurations. We want to fix that for 2.0.

As a workaround you can create a new rule copy&amp;pasting the code in `LongMethod` and configure it as you wish

cool, I will review the current threshold and se how many `@Composable` exceed 60.
If it's  common to have legitimate occurrences, I will consider as you suggest and have a custom `LongMethod`  for `@Composable` method. Thanks!

We face similar compose problem but rather with number of parameters. As it is more common to pass them destructed and not wrap to additional objects causing allocations and remember usage. So definitely split setup would be nice :+1:

Method length is probably a good sign to refactor such a composable into one that accepts “slot” parameters. Separating the concern of layout from the concern of contents, lifting the concern of state up a level, and hopefully reducing the size of the composable functions as well as making them more general.