[jira] [Commented] (MNG-5987) Document the algorithm calculating the order of plugin executions inside a phase.
[ https://issues.apache.org/jira/browse/MNG-5987?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=17729081#comment-17729081 ] Herve Boutemy commented on MNG-5987: MNG-6051 created to work on solving the limitation > Document the algorithm calculating the order of plugin executions inside a > phase. > - > > Key: MNG-5987 > URL: https://issues.apache.org/jira/browse/MNG-5987 > Project: Maven > Issue Type: Improvement > Components: Documentation: General >Reporter: Christian Schulte >Priority: Critical > > Users continuously report issues regarding the order of plugin executions: > repeating that *"this order is not expected to be guaranteed inside a phase"* > is not convincing for them. (notice that perhaps telling that it *cannot* be > guaranteed nor really controlled may be more convincing...) > The algorithm used to calculate the order of executions performed by Maven > needs to be documented: > - declaration order in the POM > - inheritance merging from parent POM, > - merging of profiles and other plugin containers, > - the order of executions of multiple executions in the same lifecycle phase, > - the sorting by plugin that happens when multiple goals are defined for the > same plugin, > etc. > based on Model Building > [https://maven.apache.org/ref/current/maven-model-builder/] ... -- This message was sent by Atlassian Jira (v8.20.10#820010)
[jira] [Commented] (MNG-5987) Document the algorithm calculating the order of plugin executions inside a phase.
[ https://issues.apache.org/jira/browse/MNG-5987?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=17729052#comment-17729052 ] Herve Boutemy commented on MNG-5987: PR created [https://github.com/apache/maven/pull/1145] please review > Document the algorithm calculating the order of plugin executions inside a > phase. > - > > Key: MNG-5987 > URL: https://issues.apache.org/jira/browse/MNG-5987 > Project: Maven > Issue Type: Improvement > Components: Documentation: General >Reporter: Christian Schulte >Priority: Critical > > Users continuously report issues regarding the order of plugin executions: > repeating that *"this order is not expected to be guaranteed inside a phase"* > is not convincing for them. (notice that perhaps telling that it *cannot* be > guaranteed nor really controlled may be more convincing...) > The algorithm used to calculate the order of executions performed by Maven > needs to be documented: > - declaration order in the POM > - inheritance merging from parent POM, > - merging of profiles and other plugin containers, > - the order of executions of multiple executions in the same lifecycle phase, > - the sorting by plugin that happens when multiple goals are defined for the > same plugin, > etc. > based on Model Building > [https://maven.apache.org/ref/current/maven-model-builder/] ... -- This message was sent by Atlassian Jira (v8.20.10#820010)
[jira] [Commented] (MNG-5987) Document the algorithm calculating the order of plugin executions inside a phase.
[ https://issues.apache.org/jira/browse/MNG-5987?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=17728930#comment-17728930 ] Herve Boutemy commented on MNG-5987: on "priority" as another way to envision more flexibility,, based on the fact that you say it currently exists as internal field, do you have any pointer to show what exists? a first look at MNG-4345 did not help me find this field > Document the algorithm calculating the order of plugin executions inside a > phase. > - > > Key: MNG-5987 > URL: https://issues.apache.org/jira/browse/MNG-5987 > Project: Maven > Issue Type: Improvement > Components: Documentation: General >Reporter: Christian Schulte >Priority: Critical > > Users continuously report issues regarding the order of plugin executions: > repeating that *"this order is not expected to be guaranteed inside a phase"* > is not convincing for them. (notice that perhaps telling that it *cannot* be > guaranteed nor really controlled may be more convincing...) > The algorithm used to calculate the order of executions performed by Maven > needs to be documented: > - declaration order in the POM > - inheritance merging from parent POM, > - merging of profiles and other plugin containers, > - the order of executions of multiple executions in the same lifecycle phase, > - the sorting by plugin that happens when multiple goals are defined for the > same plugin, > etc. > based on Model Building > [https://maven.apache.org/ref/current/maven-model-builder/] ... -- This message was sent by Atlassian Jira (v8.20.10#820010)
[jira] [Commented] (MNG-5987) Document the algorithm calculating the order of plugin executions inside a phase.
[ https://issues.apache.org/jira/browse/MNG-5987?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=17728927#comment-17728927 ] Herve Boutemy commented on MNG-5987: I fully agree Guillaume I'm just saying there are 2 steps: * explaining (and now I remember that the most surprising aspect to write down is the fact that multiple goals definition are assembled by merging one single plugin definition = what does not look obvious) * defining a new feature to be more flexible this issue is on the first step, which is "simply" documentation the next step is much more ambitious, has already have multiple approaches proposed like [https://cwiki.apache.org/confluence/display/MAVEN/Dynamic+phases] => it deserves another Jira issue, and discussion beyond Jira but more on dev ML > Document the algorithm calculating the order of plugin executions inside a > phase. > - > > Key: MNG-5987 > URL: https://issues.apache.org/jira/browse/MNG-5987 > Project: Maven > Issue Type: Improvement > Components: Documentation: General >Reporter: Christian Schulte >Priority: Critical > > Users continuously report issues regarding the order of plugin executions: > repeating that *"this order is not expected to be guaranteed inside a phase"* > is not convincing for them. (notice that perhaps telling that it *cannot* be > guaranteed nor really controlled may be more convincing...) > The algorithm used to calculate the order of executions performed by Maven > needs to be documented: > - declaration order in the POM > - inheritance merging from parent POM, > - merging of profiles and other plugin containers, > - the order of executions of multiple executions in the same lifecycle phase, > - the sorting by plugin that happens when multiple goals are defined for the > same plugin, > etc. > based on Model Building > [https://maven.apache.org/ref/current/maven-model-builder/] ... -- This message was sent by Atlassian Jira (v8.20.10#820010)
[jira] [Commented] (MNG-5987) Document the algorithm calculating the order of plugin executions inside a phase.
[ https://issues.apache.org/jira/browse/MNG-5987?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=17728592#comment-17728592 ] Guillaume Nodet commented on MNG-5987: -- I really don't think that's the only reason. If people complain that the order is not understandable, it's not just because they analyse their build for consistency between executions, it's because they actually need a specific order of plugin executions, so they need a way to actually make sure about the order. Sure, if we tell them the order is deterministic and clearly documented, they can find ways to workaround the fact that they can't explicitly order phases, but I think that's a work around. A very simple example is https://issues.apache.org/jira/browse/MNG-6051 : the test pom clearly shows the need of ordering execution between two different plugins. And give we do not support having two definitions of the same plugin (so that you could have plugin A/1, plugin B/1, plugin A/2, plugin B/2), we definitely need some support for ordering the executions. > Document the algorithm calculating the order of plugin executions inside a > phase. > - > > Key: MNG-5987 > URL: https://issues.apache.org/jira/browse/MNG-5987 > Project: Maven > Issue Type: Improvement > Components: Documentation: General >Reporter: Christian Schulte >Priority: Critical > > Users continuously report issues regarding the order of plugin executions: > repeating that *"this order is not expected to be guaranteed inside a phase"* > is not convincing for them. (notice that perhaps telling that it *cannot* be > guaranteed nor really controlled may be more convincing...) > The algorithm used to calculate the order of executions performed by Maven > needs to be documented: > - declaration order in the POM > - inheritance merging from parent POM, > - merging of profiles and other plugin containers, > - the order of executions of multiple executions in the same lifecycle phase, > - the sorting by plugin that happens when multiple goals are defined for the > same plugin, > etc. > based on Model Building > [https://maven.apache.org/ref/current/maven-model-builder/] ... -- This message was sent by Atlassian Jira (v8.20.10#820010)
[jira] [Commented] (MNG-5987) Document the algorithm calculating the order of plugin executions inside a phase.
[ https://issues.apache.org/jira/browse/MNG-5987?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=17728572#comment-17728572 ] Herve Boutemy commented on MNG-5987: is it about documenting = having people understand that model inheritance is key [https://maven.apache.org/ref/3.9.2/maven-model-builder/] or about adding new additional mechanisms thinking about it now, documenting could start by simply adding a note to the page that makes explicit the impact of model inheritance on plugins order > Document the algorithm calculating the order of plugin executions inside a > phase. > - > > Key: MNG-5987 > URL: https://issues.apache.org/jira/browse/MNG-5987 > Project: Maven > Issue Type: Improvement > Components: Documentation: General >Reporter: Christian Schulte >Priority: Critical > > Users continuously report issues regarding the order of plugin executions: > repeating that *"this order is not expected to be guaranteed inside a phase"* > is not convincing for them. (notice that perhaps telling that it *cannot* be > guaranteed nor really controlled may be more convincing...) > The algorithm used to calculate the order of executions performed by Maven > needs to be documented: > - declaration order in the POM > - inheritance merging from parent POM, > - merging of profiles and other plugin containers, > - the order of executions of multiple executions in the same lifecycle phase, > - the sorting by plugin that happens when multiple goals are defined for the > same plugin, > etc. > based on Model Building > [https://maven.apache.org/ref/current/maven-model-builder/] ... -- This message was sent by Atlassian Jira (v8.20.10#820010)
[jira] [Commented] (MNG-5987) Document the algorithm calculating the order of plugin executions inside a phase.
[
https://issues.apache.org/jira/browse/MNG-5987?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=17728504#comment-17728504
]
Christopher Tubbs commented on MNG-5987:
Having a public "priority" field would be wonderful, but if two plugin
executions are defined for the same phase and priority, documenting the order
would still be needed, even if it's documented as "not defined" or "arbitrary
order" (forcing users to set a priority if they care). Another reason having
that public would be that it would help plugins like sortpom-maven-plugin, to
organize plugins in the POM without worrying about messing up the execution
order. Alternatively, it'd be great if "lifecycle phase" was a first-class
citizen in the POM, with plugins attached to it as children of the phase
element, rather than this constructed only internally, and obfuscated to users
by an obscure (and optional) {{}} element inside the execution config.
This obfuscation is probably the biggest confusion I have to explain to new
Maven users... they simply don't understand intuitively that Maven is based on
a lifecycle with attached plugins. Having the lifecycle/phase be a first-class
citizen in the POM makes this much more intuitive.
> Document the algorithm calculating the order of plugin executions inside a
> phase.
> -
>
> Key: MNG-5987
> URL: https://issues.apache.org/jira/browse/MNG-5987
> Project: Maven
> Issue Type: Improvement
> Components: Documentation: General
>Reporter: Christian Schulte
>Priority: Critical
>
> Users continuously report issues regarding the order of plugin executions:
> repeating that *"this order is not expected to be guaranteed inside a phase"*
> is not convincing for them. (notice that perhaps telling that it *cannot* be
> guaranteed nor really controlled may be more convincing...)
> The algorithm used to calculate the order of executions performed by Maven
> needs to be documented:
> - declaration order in the POM
> - inheritance merging from parent POM,
> - merging of profiles and other plugin containers,
> - the order of executions of multiple executions in the same lifecycle phase,
> - the sorting by plugin that happens when multiple goals are defined for the
> same plugin,
> etc.
> based on Model Building
> [https://maven.apache.org/ref/current/maven-model-builder/] ...
--
This message was sent by Atlassian Jira
(v8.20.10#820010)
[jira] [Commented] (MNG-5987) Document the algorithm calculating the order of plugin executions inside a phase.
[ https://issues.apache.org/jira/browse/MNG-5987?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=17728503#comment-17728503 ] Guillaume Nodet commented on MNG-5987: -- Note that the `priority` element has been introduced to fix https://issues.apache.org/jira/browse/MNG-4345, though it's labelled as internal. It may be that it would just be a matter of making this field public. > Document the algorithm calculating the order of plugin executions inside a > phase. > - > > Key: MNG-5987 > URL: https://issues.apache.org/jira/browse/MNG-5987 > Project: Maven > Issue Type: Improvement > Components: Documentation: General >Reporter: Christian Schulte >Priority: Critical > > Users continuously report issues regarding the order of plugin executions: > repeating that *"this order is not expected to be guaranteed inside a phase"* > is not convincing for them. (notice that perhaps telling that it *cannot* be > guaranteed nor really controlled may be more convincing...) > The algorithm used to calculate the order of executions performed by Maven > needs to be documented: > - declaration order in the POM > - inheritance merging from parent POM, > - merging of profiles and other plugin containers, > - the order of executions of multiple executions in the same lifecycle phase, > - the sorting by plugin that happens when multiple goals are defined for the > same plugin, > etc. > based on Model Building > [https://maven.apache.org/ref/current/maven-model-builder/] ... -- This message was sent by Atlassian Jira (v8.20.10#820010)
[jira] [Commented] (MNG-5987) Document the algorithm calculating the order of plugin executions inside a phase.
[ https://issues.apache.org/jira/browse/MNG-5987?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=17340597#comment-17340597 ] Herve Boutemy commented on MNG-5987: see also Dynamic phases proposal... > Document the algorithm calculating the order of plugin executions inside a > phase. > - > > Key: MNG-5987 > URL: https://issues.apache.org/jira/browse/MNG-5987 > Project: Maven > Issue Type: Improvement > Components: Documentation: General >Reporter: Christian Schulte >Priority: Critical > > Users continuously report issues regarding the order of plugin executions: > repeating that *"this order is not expected to be guaranteed inside a phase"* > is not convincing for them. (notice that perhaps telling that it *cannot* be > guaranteed nor really controlled may be more convincing...) > The algorithm used to calculate the order of executions performed by Maven > needs to be documented: > - declaration order in the POM > - inheritance merging from parent POM, > - merging of profiles and other plugin containers, > - the order of executions of multiple executions in the same lifecycle phase, > - the sorting by plugin that happens when multiple goals are defined for the > same plugin, > etc. > based on Model Building > [https://maven.apache.org/ref/current/maven-model-builder/] ... -- This message was sent by Atlassian Jira (v8.3.4#803005)
[jira] [Commented] (MNG-5987) Document the algorithm calculating the order of plugin executions inside a phase.
[ https://issues.apache.org/jira/browse/MNG-5987?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=17340594#comment-17340594 ] Herve Boutemy commented on MNG-5987: notice: sorting has to happen at goal execution level, not only plugin > Document the algorithm calculating the order of plugin executions inside a > phase. > - > > Key: MNG-5987 > URL: https://issues.apache.org/jira/browse/MNG-5987 > Project: Maven > Issue Type: Improvement > Components: Documentation: General >Reporter: Christian Schulte >Priority: Critical > > Users continuously report issues regarding the order of plugin executions: > repeating that *"this order is not expected to be guaranteed inside a phase"* > is not convincing for them. (notice that perhaps telling that it *cannot* be > guaranteed nor really controlled may be more convincing...) > The algorithm used to calculate the order of executions performed by Maven > needs to be documented: > - declaration order in the POM > - inheritance merging from parent POM, > - merging of profiles and other plugin containers, > - the order of executions of multiple executions in the same lifecycle phase, > - the sorting by plugin that happens when multiple goals are defined for the > same plugin, > etc. > based on Model Building > [https://maven.apache.org/ref/current/maven-model-builder/] ... -- This message was sent by Atlassian Jira (v8.3.4#803005)
[jira] [Commented] (MNG-5987) Document the algorithm calculating the order of plugin executions.
[ https://issues.apache.org/jira/browse/MNG-5987?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=17228449#comment-17228449 ] Delany commented on MNG-5987: - I don't want to have to rename default plugin executions in order to line them all up correctly. Rather introduce an execution *priority* tag, with possible values 0-255. That way you don't break existing functionality. You could also make a maven-enforcer-plugin rule that finds clashing priority values. > Document the algorithm calculating the order of plugin executions. > -- > > Key: MNG-5987 > URL: https://issues.apache.org/jira/browse/MNG-5987 > Project: Maven > Issue Type: Improvement > Components: Documentation: General >Reporter: Christian Schulte >Priority: Critical > > Users continuously report issues regarding the order of plugin executions: > repeating that this order is not expected to be guaranteed inside a phase is > not convincing for them. > The algorithm used to calculate the order of executions performed by Maven > needs to be documented: > - declaration order in the POM > - inheritance merging from parent POM, > - merging of profiles and other plugin containers, > - the order of executions of multiple executions in the same lifecycle phase, > etc. -- This message was sent by Atlassian Jira (v8.3.4#803005)
[jira] [Commented] (MNG-5987) Document the algorithm calculating the order of plugin executions.
[ https://issues.apache.org/jira/browse/MNG-5987?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=16819658#comment-16819658 ] miowang commented on MNG-5987: -- I've encountered the same issue, I do believe it should be documented better. here is my understanding after went through several code in maven. When a maven build triggered, maven core will resolve all of the plugins from pom and parent poms, and put them in a list For plugins binding to same phase, the execution order is base on order in the list actually. Most of the time it is same with the order user declared in his/her pom because maven core append user's plugins to the bottom of parents' plugins, while sometimes it's not. take the case below for example # user declares A, B, C, D in parent pom, all of them are binding to the same phase. # now user declares E, C, F and B in sub pom, E and F are also binding to the same phase Then the order in resolved plugin list will be A, F, B, E, C, D. *F will be executed before E.* The reason is # user can redeclare the plugins in sub pom, while maven core keeps the order they were declared in parent pom. # for any plugins declared before the re-declared plugin, maven core will put them before the re-declared plugin in resolved list More details in [https://github.com/apache/maven/blob/master/maven-model-builder/src/main/java/org/apache/maven/model/inheritance/DefaultInheritanceAssembler.java#L241] > Document the algorithm calculating the order of plugin executions. > -- > > Key: MNG-5987 > URL: https://issues.apache.org/jira/browse/MNG-5987 > Project: Maven > Issue Type: Improvement >Reporter: Christian Schulte >Priority: Critical > > Users continuously report issues regarding the order of plugin executions: > repeating that this order is not expected to be guaranteed inside a phase is > not convincing for them. > The algorithm used to calculate the order of executions performed by Maven > needs to be documented: > - declaration order in the POM > - inheritance merging from parent POM, > - merging of profiles and other plugin containers, > - the order of executions of multiple executions in the same lifecycle phase, > etc. -- This message was sent by Atlassian JIRA (v7.6.3#76005)
[jira] [Commented] (MNG-5987) Document the algorithm calculating the order of plugin executions.
[ https://issues.apache.org/jira/browse/MNG-5987?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=15360112#comment-15360112 ] Gerhard Poul commented on MNG-5987: --- If that is indeed the case, then it could be a lot better documented. If you for example look at https://issues.apache.org/jira/browse/MNG-5799?focusedCommentId=15173347&page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel#comment-15173347 you'll see that I did indeed notice something in the documentation that would indicate otherwise. > Document the algorithm calculating the order of plugin executions. > -- > > Key: MNG-5987 > URL: https://issues.apache.org/jira/browse/MNG-5987 > Project: Maven > Issue Type: Improvement >Reporter: Christian Schulte >Priority: Critical > > Users continuously report issues regarding the order of plugin executions: > repeating that this order is not expected to be guaranteed inside a phase is > not convincing for them. > The algorithm used to calculate the order of executions performed by Maven > needs to be documented: > - declaration order in the POM > - inheritance merging from parent POM, > - merging of profiles and other plugin containers, > - the order of executions of multiple executions in the same lifecycle phase, > etc. -- This message was sent by Atlassian JIRA (v6.3.4#6332)
[jira] [Commented] (MNG-5987) Document the algorithm calculating the order of plugin executions.
[ https://issues.apache.org/jira/browse/MNG-5987?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=15360031#comment-15360031 ] Hervé Boutemy commented on MNG-5987: bq. Order of declaration is really unreliable and complicated to understand when it comes to profiles and parents, and I'm not sure was ever really well-defined (or at least well-documented) it was documented and chosen that order of execution is not something you can count on: phases are ordered, mojos in a phase simply are not and we never pushed this to making it random, whouch would have been one way to make people understand that order of executionin a phase is not expected to be controlled: that is the design (that so much people don't want to understand when we explain them again and again) > Document the algorithm calculating the order of plugin executions. > -- > > Key: MNG-5987 > URL: https://issues.apache.org/jira/browse/MNG-5987 > Project: Maven > Issue Type: Improvement >Reporter: Christian Schulte >Priority: Critical > > Users continuously report issues regarding the order of plugin executions: > repeating that this order is not expected to be guaranteed inside a phase is > not convincing for them. > The algorithm used to calculate the order of executions performed by Maven > needs to be documented: > - declaration order in the POM > - inheritance merging from parent POM, > - merging of profiles and other plugin containers, > - the order of executions of multiple executions in the same lifecycle phase, > etc. -- This message was sent by Atlassian JIRA (v6.3.4#6332)
[jira] [Commented] (MNG-5987) Document the algorithm calculating the order of plugin executions.
[ https://issues.apache.org/jira/browse/MNG-5987?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=15357659#comment-15357659 ] Christopher Tubbs commented on MNG-5987: It's a breaking change in behavior yes, but it's at least a predictable one. I'm not sure a better way to move forward. Order of declaration is really unreliable and complicated to understand when it comes to profiles and parents, and I'm not sure was ever really well-defined (or at least well-documented). Order of execution is also disrupted when you override an execution by its execution id in a child POM, but that child's execution order is different from the parent's. Overall, I think execution id is better, and the transition cost is worth it. > Document the algorithm calculating the order of plugin executions. > -- > > Key: MNG-5987 > URL: https://issues.apache.org/jira/browse/MNG-5987 > Project: Maven > Issue Type: Improvement >Reporter: Christian Schulte >Priority: Critical > > Users continuously report issues regarding the order of plugin executions: > repeating that this order is not expected to be guaranteed inside a phase is > not convincing for them. > The algorithm used to calculate the order of executions performed by Maven > needs to be documented: > - declaration order in the POM > - inheritance merging from parent POM, > - merging of profiles and other plugin containers, > - the order of executions of multiple executions in the same lifecycle phase, > etc. -- This message was sent by Atlassian JIRA (v6.3.4#6332)
[jira] [Commented] (MNG-5987) Document the algorithm calculating the order of plugin executions.
[ https://issues.apache.org/jira/browse/MNG-5987?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=15357640#comment-15357640 ] Christian Schulte commented on MNG-5987: For all user executions no matter where declared (POM, profile). Executions coming from the default lifecycle bindings would not change. So whatever execution is declared in the POM or profile will be sorted based on execution id. Issue with doing this is that we would give up on the "order of declaration" users rely on - intentionally or unintentionally. > Document the algorithm calculating the order of plugin executions. > -- > > Key: MNG-5987 > URL: https://issues.apache.org/jira/browse/MNG-5987 > Project: Maven > Issue Type: Improvement >Reporter: Christian Schulte >Priority: Critical > > Users continuously report issues regarding the order of plugin executions: > repeating that this order is not expected to be guaranteed inside a phase is > not convincing for them. > The algorithm used to calculate the order of executions performed by Maven > needs to be documented: > - declaration order in the POM > - inheritance merging from parent POM, > - merging of profiles and other plugin containers, > - the order of executions of multiple executions in the same lifecycle phase, > etc. -- This message was sent by Atlassian JIRA (v6.3.4#6332)
[jira] [Commented] (MNG-5987) Document the algorithm calculating the order of plugin executions.
[
https://issues.apache.org/jira/browse/MNG-5987?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=15357546#comment-15357546
]
Christopher Tubbs commented on MNG-5987:
I also prefer ordering based on execution id. I also agree with using
{{Locale#ROOT}}.
The question for me is, is this a global ordering, across all sources (active
profiles, parents, parents of parents, etc.), or just an ordering within a
given source? My preference is a global ordering after adding all plugin
executions from all sources. It's the simplest to understand and manipulate.
> Document the algorithm calculating the order of plugin executions.
> --
>
> Key: MNG-5987
> URL: https://issues.apache.org/jira/browse/MNG-5987
> Project: Maven
> Issue Type: Improvement
>Reporter: Christian Schulte
>Priority: Critical
>
> Users continuously report issues regarding the order of plugin executions:
> repeating that this order is not expected to be guaranteed inside a phase is
> not convincing for them.
> The algorithm used to calculate the order of executions performed by Maven
> needs to be documented:
> - declaration order in the POM
> - inheritance merging from parent POM,
> - merging of profiles and other plugin containers,
> - the order of executions of multiple executions in the same lifecycle phase,
> etc.
--
This message was sent by Atlassian JIRA
(v6.3.4#6332)
[jira] [Commented] (MNG-5987) Document the algorithm calculating the order of plugin executions.
[ https://issues.apache.org/jira/browse/MNG-5987?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=15353991#comment-15353991 ] Christian Schulte commented on MNG-5987: As a starting point: MNG-3719, MNG-3925, MNG-4975 contain descriptions about the way Maven is expected to order executions. > Document the algorithm calculating the order of plugin executions. > -- > > Key: MNG-5987 > URL: https://issues.apache.org/jira/browse/MNG-5987 > Project: Maven > Issue Type: Improvement >Reporter: Christian Schulte >Priority: Critical > > Users continuously report issues regarding the order of plugin executions: > repeating that this order is not expected to be guaranteed inside a phase is > not convincing for them. > The algorithm used to calculate the order of executions performed by Maven > needs to be documented: > - declaration order in the POM > - inheritance merging from parent POM, > - merging of profiles and other plugin containers, > - the order of executions of multiple executions in the same lifecycle phase, > etc. -- This message was sent by Atlassian JIRA (v6.3.4#6332)
[jira] [Commented] (MNG-5987) Document the algorithm calculating the order of plugin executions.
[ https://issues.apache.org/jira/browse/MNG-5987?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=15353983#comment-15353983 ] Christian Schulte commented on MNG-5987: I have looked at those issues. It seems this is just normal Maven behaviour. We need to document that, of course. Still - if people continuously report plugin execution ordering related issues, Maven does something in a way users would not expect it to. So the issue at hand really is: "What is so strange about the way Maven performs plugin execution ordering that users independently of each other run into issues with it and report the normal behaviour as beeing a bug?" > Document the algorithm calculating the order of plugin executions. > -- > > Key: MNG-5987 > URL: https://issues.apache.org/jira/browse/MNG-5987 > Project: Maven > Issue Type: Improvement >Reporter: Christian Schulte >Priority: Critical > > Users continuously report issues regarding the order of plugin executions: > repeating that this order is not expected to be guaranteed inside a phase is > not convincing for them. > The algorithm used to calculate the order of executions performed by Maven > needs to be documented: > - declaration order in the POM > - inheritance merging from parent POM, > - merging of profiles and other plugin containers, > - the order of executions of multiple executions in the same lifecycle phase, > etc. -- This message was sent by Atlassian JIRA (v6.3.4#6332)
[jira] [Commented] (MNG-5987) Document the algorithm calculating the order of plugin executions.
[ https://issues.apache.org/jira/browse/MNG-5987?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=15353965#comment-15353965 ] Christian Schulte commented on MNG-5987: I am not sure what to do about this. Implementing this is easy. Doing so will make some ITs fail which are written to test for POM declaration ordering issues. These ITs will start to fail because the execution ids in use will lead to a different order than expected. What to do? Please take a look at MNG-4975. Ordering based on execution id is a good idea, I think. I can commit that now and update some execution ids of failing ITs. Can we change the order of plugin executions in 3.4? > Document the algorithm calculating the order of plugin executions. > -- > > Key: MNG-5987 > URL: https://issues.apache.org/jira/browse/MNG-5987 > Project: Maven > Issue Type: Improvement >Reporter: Christian Schulte >Priority: Critical > > Users continuously report issues regarding the order of plugin executions: > repeating that this order is not expected to be guaranteed inside a phase is > not convincing for them. > The algorithm used to calculate the order of executions performed by Maven > needs to be documented: > - declaration order in the POM > - inheritance merging from parent POM, > - merging of profiles and other plugin containers, > - the order of executions of multiple executions in the same lifecycle phase, > etc. -- This message was sent by Atlassian JIRA (v6.3.4#6332)
[jira] [Commented] (MNG-5987) Document the algorithm calculating the order of plugin executions.
[ https://issues.apache.org/jira/browse/MNG-5987?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=15353580#comment-15353580 ] Michael Osipov commented on MNG-5987: - I think `Locale#ROOT` is better suited for this. > Document the algorithm calculating the order of plugin executions. > -- > > Key: MNG-5987 > URL: https://issues.apache.org/jira/browse/MNG-5987 > Project: Maven > Issue Type: Improvement >Reporter: Christian Schulte >Priority: Critical > > Users continuously report issues regarding the order of plugin executions: > repeating that this order is not expected to be guaranteed inside a phase is > not convincing for them. > The algorithm used to calculate the order of executions performed by Maven > needs to be documented: > - declaration order in the POM > - inheritance merging from parent POM, > - merging of profiles and other plugin containers, > - the order of executions of multiple executions in the same lifecycle phase, > etc. -- This message was sent by Atlassian JIRA (v6.3.4#6332)
[jira] [Commented] (MNG-5987) Document the algorithm calculating the order of plugin executions.
[
https://issues.apache.org/jira/browse/MNG-5987?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=15353501#comment-15353501
]
Christian Schulte commented on MNG-5987:
Would it be ok to order plugin executions based on the execution id? Could this
be done in 3.4? It will change the order of plugin executions but people get a
chance to use the execution id to declare the order of executions manually.
{code}
java.text.Collator.getInstance( java.util.Locale.US ).compare( executionId1,
executionId2 );
{code}
> Document the algorithm calculating the order of plugin executions.
> --
>
> Key: MNG-5987
> URL: https://issues.apache.org/jira/browse/MNG-5987
> Project: Maven
> Issue Type: Improvement
>Reporter: Christian Schulte
>Priority: Critical
>
> Users continuously report issues regarding the order of plugin executions:
> repeating that this order is not expected to be guaranteed inside a phase is
> not convincing for them.
> The algorithm used to calculate the order of executions performed by Maven
> needs to be documented:
> - declaration order in the POM
> - inheritance merging from parent POM,
> - merging of profiles and other plugin containers,
> - the order of executions of multiple executions in the same lifecycle phase,
> etc.
--
This message was sent by Atlassian JIRA
(v6.3.4#6332)
[jira] [Commented] (MNG-5987) Document the algorithm calculating the order of plugin executions.
[ https://issues.apache.org/jira/browse/MNG-5987?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=15178628#comment-15178628 ] Christian Schulte commented on MNG-5987: We discussed this a bit on dev@. See [http://www.mail-archive.com/dev@maven.apache.org/msg108718.html]. We'll need further analysis to get to a final solution. Documenting the current behaviour is a starting point and already may uncover inconsistencies/bugs to fix in 3.4. Let's use this issue to gather related information at a central point. I'll write up some descriptions of the various merging strategies currently performed by Maven as much as possible so we have something to talk about. I think the model will need to be enhanced in 4.x so that all kinds of ordering issues (not just plugin executions) can be declared explicity and not depend on XML parser implementation details. > Document the algorithm calculating the order of plugin executions. > -- > > Key: MNG-5987 > URL: https://issues.apache.org/jira/browse/MNG-5987 > Project: Maven > Issue Type: Improvement >Reporter: Christian Schulte >Priority: Critical > > Users continuously report issues regarding the order of plugin executions: > repeating that this order is not expected to be guaranteed inside a phase is > not convincing for them. > The algorithm used to calculate the order of executions performed by Maven > needs to be documented: > - declaration order in the POM > - inheritance merging from parent POM, > - merging of profiles and other plugin containers, > - the order of executions of multiple executions in the same lifecycle phase, > etc. -- This message was sent by Atlassian JIRA (v6.3.4#6332)
[jira] [Commented] (MNG-5987) Document the algorithm calculating the order of plugin executions.
[ https://issues.apache.org/jira/browse/MNG-5987?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=15178369#comment-15178369 ] Christopher Tubbs commented on MNG-5987: I don't think this issue is *just* about documenting it. The issues that were closed in favor of this (MNG-4578, and its more informative duplicate MNG-5539) identify the fact that plugin execution order is *NOT preserved* when the plugins are merged in from profiles. It doesn't matter whether the current behavior is documented or not... it is still a problem that the order is not preserved. Closing those other issues implies this is a documentation issue only... when really it's a behavior problem. > Document the algorithm calculating the order of plugin executions. > -- > > Key: MNG-5987 > URL: https://issues.apache.org/jira/browse/MNG-5987 > Project: Maven > Issue Type: Improvement >Reporter: Christian Schulte >Priority: Critical > > Users continuously report issues regarding the order of plugin executions: > repeating that this order is not expected to be guaranteed inside a phase is > not convincing for them. > The algorithm used to calculate the order of executions performed by Maven > needs to be documented: > - declaration order in the POM > - inheritance merging from parent POM, > - merging of profiles and other plugin containers, > - the order of executions of multiple executions in the same lifecycle phase, > etc. -- This message was sent by Atlassian JIRA (v6.3.4#6332)
[jira] [Commented] (MNG-5987) Document the algorithm calculating the order of plugin executions.
[ https://issues.apache.org/jira/browse/MNG-5987?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=15177405#comment-15177405 ] Christian Schulte commented on MNG-5987: Users continuously report issues regarding the order of plugin executions. The algorithm used to calculate the order of executions performed by Maven needs to be documented. Meaning of declaration order in the POM, the merging of profiles and other plugin containers, the order of executions of multiple executions in the same lifecycle phase, etc. > Document the algorithm calculating the order of plugin executions. > -- > > Key: MNG-5987 > URL: https://issues.apache.org/jira/browse/MNG-5987 > Project: Maven > Issue Type: Improvement >Reporter: Christian Schulte >Priority: Critical > -- This message was sent by Atlassian JIRA (v6.3.4#6332)
