You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@camel.apache.org by gn...@apache.org on 2020/09/15 12:51:37 UTC
[camel] 04/06: [CAMEL-15433] Generators should run during a
component build
This is an automated email from the ASF dual-hosted git repository.
gnodet pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/camel.git
commit a3460edb5bae91244743b7cbf115725bcc8c1806
Author: Guillaume Nodet <gn...@gmail.com>
AuthorDate: Mon Sep 14 15:56:09 2020 +0200
[CAMEL-15433] Generators should run during a component build
---
.../modules/languages/pages/constant-language.adoc | 81 ++
.../languages/pages/exchangeProperty-language.adoc | 67 ++
.../modules/languages/pages/file-language.adoc | 301 +++++++
.../modules/languages/pages/header-language.adoc | 51 ++
.../modules/languages/pages/ref-language.adoc | 64 ++
.../modules/languages/pages/simple-language.adoc | 883 +++++++++++++++++++++
.../modules/languages/pages/tokenize-language.adoc | 46 ++
.../languages/pages/xtokenize-language.adoc | 38 +
docs/gulpfile.js | 2 -
.../maven/packaging/PrepareComponentMojo.java | 8 +
10 files changed, 1539 insertions(+), 2 deletions(-)
diff --git a/docs/components/modules/languages/pages/constant-language.adoc b/docs/components/modules/languages/pages/constant-language.adoc
new file mode 100644
index 0000000..8659da1
--- /dev/null
+++ b/docs/components/modules/languages/pages/constant-language.adoc
@@ -0,0 +1,81 @@
+[[constant-language]]
+= Constant Language
+//THIS FILE IS COPIED: EDIT THE SOURCE FILE:
+:page-source: core/camel-core-languages/src/main/docs/modules/languages/pages/constant-language.adoc
+:docTitle: Constant
+:artifactId: camel-core-languages
+:description: A fixed value set only once during the route startup.
+:since: 1.5
+:supportLevel: Stable
+
+*Since Camel {since}*
+
+The Constant Expression Language is really just a way to specify
+constant strings as a type of expression.
+
+[NOTE]
+====
+This is a fixed constant value that is only set once during starting up the route,
+do not use this if you want dynamic values during routing.
+====
+
+== Constant Options
+
+
+// language options: START
+The Constant language supports 1 options, which are listed below.
+
+
+
+[width="100%",cols="2,1m,1m,6",options="header"]
+|===
+| Name | Default | Java Type | Description
+| trim | true | Boolean | Whether to trim the value to remove leading and trailing whitespaces and line breaks
+|===
+// language options: END
+
+
+== Example usage
+
+The setHeader element of the Spring DSL can utilize a constant
+expression like:
+
+[source,xml]
+----
+<route>
+ <from uri="seda:a"/>
+ <setHeader name="theHeader">
+ <constant>the value</constant>
+ </setHeader>
+ <to uri="mock:b"/>
+</route>
+----
+
+in this case, the Message coming from the seda:a
+Endpoint will have 'theHeader' header set to the
+constant value 'the value'.
+
+And the same example using Java DSL:
+
+[source,java]
+----
+from("seda:a")
+ .setHeader("theHeader", constant("the value"))
+ .to("mock:b");
+----
+
+== Loading constant from external resource
+
+You can externalize the constant and have Camel load it from a resource
+such as `"classpath:"`, `"file:"`, or `"http:"`. +
+ This is done using the following syntax: `"resource:scheme:location"`,
+eg to refer to a file on the classpath you can do:
+
+[source,java]
+----
+.setHeader("myHeader").constant("resource:classpath:constant.txt")
+----
+
+== Dependencies
+
+The Constant language is part of *camel-core*.
diff --git a/docs/components/modules/languages/pages/exchangeProperty-language.adoc b/docs/components/modules/languages/pages/exchangeProperty-language.adoc
new file mode 100644
index 0000000..1675a91
--- /dev/null
+++ b/docs/components/modules/languages/pages/exchangeProperty-language.adoc
@@ -0,0 +1,67 @@
+[[exchangeProperty-language]]
+= ExchangeProperty Language
+//THIS FILE IS COPIED: EDIT THE SOURCE FILE:
+:page-source: core/camel-core-languages/src/main/docs/modules/languages/pages/exchangeProperty-language.adoc
+:docTitle: ExchangeProperty
+:artifactId: camel-core-languages
+:description: Get the value of named Camel Exchange property.
+:since: 2.0
+:supportLevel: Stable
+
+*Since Camel {since}*
+
+The ExchangeProperty Expression Language allows you to extract values of
+named exchange properties.
+
+== Exchange Property Options
+
+// language options: START
+The ExchangeProperty language supports 1 options, which are listed below.
+
+
+
+[width="100%",cols="2,1m,1m,6",options="header"]
+|===
+| Name | Default | Java Type | Description
+| trim | true | Boolean | Whether to trim the value to remove leading and trailing whitespaces and line breaks
+|===
+// language options: END
+
+== Example usage
+
+The recipientList element of the Spring DSL can utilize a
+exchangeProperty expression like:
+
+In this case, the list of recipients are contained in the property
+'myProperty'.
+
+[source,xml]
+----
+<route>
+ <from uri="direct:a" />
+ <recipientList>
+ <exchangeProperty>myProperty</exchangeProperty>
+ </recipientList>
+</route>
+----
+
+And the same example in Java DSL:
+
+[source,java]
+----
+from("direct:a").recipientList(exchangeProperty("myProperty"));
+----
+
+And with a slightly different syntax where you use the builder to the
+fullest (i.e. avoid using parameters but using stacked operations,
+notice that exchangeProperty is not a parameter but a stacked method
+call)
+
+[source,java]
+----
+from("direct:a").recipientList().exchangeProperty("myProperty");
+----
+
+== Dependencies
+
+The ExchangeProperty language is part of *camel-core*.
diff --git a/docs/components/modules/languages/pages/file-language.adoc b/docs/components/modules/languages/pages/file-language.adoc
new file mode 100644
index 0000000..2c4dc56
--- /dev/null
+++ b/docs/components/modules/languages/pages/file-language.adoc
@@ -0,0 +1,301 @@
+[[file-language]]
+= File Language
+//THIS FILE IS COPIED: EDIT THE SOURCE FILE:
+:page-source: core/camel-core-languages/src/main/docs/modules/languages/pages/file-language.adoc
+:docTitle: File
+:artifactId: camel-core-languages
+:description: For expressions and predicates using the file/simple language.
+:since: 1.1
+:supportLevel: Stable
+
+*Since Camel {since}*
+
+The file language is merged with
+xref:simple-language.adoc[Simple] language which means you can use all the file
+syntax directly within the simple language.
+
+The File Expression Language is an extension to the
+xref:simple-language.adoc[Simple] language, adding file related capabilities.
+These capabilities are related to common use cases working with file
+path and names. The goal is to allow expressions to be used with the
+File and FTP components for setting
+dynamic file patterns for both consumer and producer.
+
+== File Language options
+
+// language options: START
+The File language supports 2 options, which are listed below.
+
+
+
+[width="100%",cols="2,1m,1m,6",options="header"]
+|===
+| Name | Default | Java Type | Description
+| resultType | | String | Sets the class name of the result type (type from output)
+| trim | true | Boolean | Whether to trim the value to remove leading and trailing whitespaces and line breaks
+|===
+// language options: END
+
+== Syntax
+
+This language is an *extension* to the xref:simple-language.adoc[Simple] language
+so the xref:simple-language.adoc[Simple] syntax applies also. So the table below
+only lists the additional. +
+ As opposed to xref:simple-language.adoc[Simple] language
+xref:file-language.adoc[File Language] also supports
+xref:constant-language.adoc[Constant] expressions so you can enter a fixed
+filename.
+
+All the file tokens use the same expression name as the method on the
+`java.io.File` object, for instance `file:absolute` refers to the
+`java.io.File.getAbsolute()` method. Notice that not all expressions are
+supported by the current Exchange. For instance the xref:components::ftp-component.adoc[FTP]
+component supports some of the options, where as the
+File component supports all of them.
+
+
+[width="100%",cols="10%,10%,10%,10%,10%,25%,25%",options="header",]
+|===
+|Expression |Type |File Consumer |File Producer |FTP Consumer |FTP Producer |Description
+
+|file:name |String |yes |no |yes |no |refers to the file name (is relative to the starting directory, see note
+below)
+
+|file:name.ext |String |yes |no |yes |no |refers to the file extension only
+
+|file:name.ext.single |String |yes |no |yes |no |refers to the file extension. If the file
+extension has mutiple dots, then this expression strips and only returns
+the last part.
+
+|file:name.noext |String |yes |no |yes |no |refers to the file name with no extension (is relative to the starting
+directory, see note below)
+
+|file:name.noext.single |String |yes |no |yes |no |refers to the file name with no extension (is
+relative to the starting directory, see note below). If the file
+extension has multiple dots, then this expression strips only the last
+part, and keep the others.
+
+|file:onlyname |String |yes |no |yes |no |refers to the file name only with no leading paths.
+
+|file:onlyname.noext |String |yes |no |yes |no |refers to the file name only with no extension and with no leading
+paths.
+
+|file:onlyname.noext.single |String |yes |no |yes |no |refers to the file name only with no extension and
+with no leading paths. If the file extension has multiple dots, then
+this expression strips only the last part, and keep the others.
+
+|file:ext |String |yes |no |yes |no |refers to the file extension only
+
+|file:parent |String |yes |no |yes |no |refers to the file parent
+
+|file:path |String |yes |no |yes |no |refers to the file path
+
+|file:absolute |Boolean |yes |no |no |no |refers to whether the file is regarded as absolute or relative
+
+|file:absolute.path |String |yes |no |no |no |refers to the absolute file path
+
+|file:length |Long |yes |no |yes |no |refers to the file length returned as a Long type
+
+|file:size |Long |yes |no |yes |no |refers to the file length returned as a Long type
+
+|file:modified |Date |yes |no |yes |no |Refers to the file last modified returned as a Date type
+
+|date:_command:pattern_ |String |yes |yes |yes |yes |for date formatting using the `java.text.SimpleDateFormat` patterns. Is
+an *extension* to the xref:simple-language.adoc[Simple] language. Additional
+command is: *file* (consumers only) for the last modified timestamp of
+the file. Notice: all the commands from the xref:simple-language.adoc[Simple]
+language can also be used.
+|===
+
+== File token example
+
+=== Relative paths
+
+We have a `java.io.File` handle for the file `hello.txt` in the
+following *relative* directory: `.\filelanguage\test`. And we configure
+our endpoint to use this starting directory `.\filelanguage`. The file
+tokens will return as:
+
+[width="100%",cols="50%,50%",options="header",]
+|===
+|Expression |Returns
+
+|file:name |test\hello.txt
+
+|file:name.ext |txt
+
+|file:name.noext |test\hello
+
+|file:onlyname |hello.txt
+
+|file:onlyname.noext |hello
+
+|file:ext |txt
+
+|file:parent |filelanguage\test
+
+|file:path |filelanguage\test\hello.txt
+
+|file:absolute |false
+
+|file:absolute.path |\workspace\camel\camel-core\target\filelanguage\test\hello.txt
+|===
+
+=== Absolute paths
+
+We have a `java.io.File` handle for the file `hello.txt` in the
+following *absolute* directory:
+`\workspace\camel\camel-core\target\filelanguage\test`. And we configure
+out endpoint to use the absolute starting directory
+`\workspace\camel\camel-core\target\filelanguage`. The file tokens will
+return as:
+
+[width="100%",cols="50%,50%",options="header",]
+|===
+|Expression |Returns
+
+|file:name |test\hello.txt
+
+|file:name.ext |txt
+
+|file:name.noext |test\hello
+
+|file:onlyname |hello.txt
+
+|file:onlyname.noext |hello
+
+|file:ext |txt
+
+|file:parent |\workspace\camel\camel-core\target\filelanguage\test
+
+|file:path |\workspace\camel\camel-core\target\filelanguage\test\hello.txt
+
+|file:absolute |true
+
+|file:absolute.path |\workspace\camel\camel-core\target\filelanguage\test\hello.txt
+|===
+
+== Samples
+
+You can enter a fixed xref:constant-language.adoc[Constant] expression such as
+`myfile.txt`:
+
+[source]
+----
+fileName="myfile.txt"
+----
+
+Lets assume we use the file consumer to read files and want to move the
+read files to backup folder with the current date as a sub folder. This
+can be archieved using an expression like:
+
+[source]
+----
+fileName="backup/${date:now:yyyyMMdd}/${file:name.noext}.bak"
+----
+
+relative folder names are also supported so suppose the backup folder
+should be a sibling folder then you can append .. as:
+
+[source]
+----
+fileName="../backup/${date:now:yyyyMMdd}/${file:name.noext}.bak"
+----
+
+As this is an extension to the xref:simple-language.adoc[Simple] language we have
+access to all the goodies from this language also, so in this use case
+we want to use the in.header.type as a parameter in the dynamic
+expression:
+
+[source]
+----
+fileName="../backup/${date:now:yyyyMMdd}/type-${in.header.type}/backup-of-${file:name.noext}.bak"
+----
+
+If you have a custom Date you want to use in the expression then Camel
+supports retrieving dates from the message header.
+
+[source]
+----
+fileName="orders/order-${in.header.customerId}-${date:in.header.orderDate:yyyyMMdd}.xml"
+----
+
+And finally we can also use a bean expression to invoke a POJO class
+that generates some String output (or convertible to String) to be used:
+
+[source]
+----
+fileName="uniquefile-${bean:myguidgenerator.generateid}.txt"
+----
+
+And of course all this can be combined in one expression where you can
+use the xref:file-language.adoc[File Language], xref:file-language.adoc[Simple]
+and the xref:components::bean-component.adoc[Bean] language in one combined expression. This
+is pretty powerful for those common file path patterns.
+
+== Using Spring PropertyPlaceholderConfigurer together with the File component
+
+In Camel you can use the xref:file-language.adoc[File Language] directly
+from the xref:simple-language.adoc[Simple] language which makes a
+Content Based Router easier to do in
+Spring XML, where we can route based on file extensions as shown below:
+
+[source,xml]
+----
+<from uri="file://input/orders"/>
+ <choice>
+ <when>
+ <simple>${file:ext} == 'txt'</simple>
+ <to uri="bean:orderService?method=handleTextFiles"/>
+ </when>
+ <when>
+ <simple>${file:ext} == 'xml'</simple>
+ <to uri="bean:orderService?method=handleXmlFiles"/>
+ </when>
+ <otherwise>
+ <to uri="bean:orderService?method=handleOtherFiles"/>
+ </otherwise>
+ </choice>
+----
+
+If you use the `fileName` option on the File endpoint
+to set a dynamic filename using the xref:file-language.adoc[File Language] then make sure you +
+ use the alternative syntax to avoid
+clashing with Springs `PropertyPlaceholderConfigurer`.
+
+*bundle-context.xml*
+
+[source,xml]
+----
+<bean id="propertyPlaceholder" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
+ <property name="location" value="classpath:bundle-context.cfg" />
+</bean>
+
+<bean id="sampleRoute" class="SampleRoute">
+ <property name="fromEndpoint" value="${fromEndpoint}" />
+ <property name="toEndpoint" value="${toEndpoint}" />
+</bean>
+----
+
+*bundle-context.cfg*
+
+[source]
+----
+fromEndpoint=activemq:queue:test
+toEndpoint=file://fileRoute/out?fileName=test-$simple{date:now:yyyyMMdd}.txt
+----
+
+Notice how we use the $simple\{ } syntax in the `toEndpoint` above. +
+ If you don't do this, there is a clash and Spring will throw an
+exception like
+
+[source,java]
+----------------------------------------------------------------------------------------------------
+org.springframework.beans.factory.BeanDefinitionStoreException:
+Invalid bean definition with name 'sampleRoute' defined in class path resource [bundle-context.xml]:
+Could not resolve placeholder 'date:now:yyyyMMdd'
+----------------------------------------------------------------------------------------------------
+
+== Dependencies
+
+The File language is part of *camel-core*.
diff --git a/docs/components/modules/languages/pages/header-language.adoc b/docs/components/modules/languages/pages/header-language.adoc
new file mode 100644
index 0000000..87e211b
--- /dev/null
+++ b/docs/components/modules/languages/pages/header-language.adoc
@@ -0,0 +1,51 @@
+[[header-language]]
+= Header Language
+//THIS FILE IS COPIED: EDIT THE SOURCE FILE:
+:page-source: core/camel-core-languages/src/main/docs/modules/languages/pages/header-language.adoc
+:docTitle: Header
+:artifactId: camel-core-languages
+:description: Get the value of the named Camel Message header.
+:since: 1.5
+:supportLevel: Stable
+
+*Since Camel {since}*
+
+The Header Expression Language allows you to extract values of named
+headers.
+
+== Header Options
+
+// language options: START
+The Header language supports 1 options, which are listed below.
+
+
+
+[width="100%",cols="2,1m,1m,6",options="header"]
+|===
+| Name | Default | Java Type | Description
+| trim | true | Boolean | Whether to trim the value to remove leading and trailing whitespaces and line breaks
+|===
+// language options: END
+
+== Example usage
+
+The recipientList element of the Spring DSL can utilize a header
+expression like:
+
+In this case, the list of recipients are contained in the header
+'myHeader'.
+
+And the same example in Java DSL:
+
+And with a slightly different syntax where you use the builder to the
+fullest (i.e. avoid using parameters but using stacked operations,
+notice that header is not a parameter but a stacked method call)
+
+[source,java]
+----
+from("direct:a").recipientList().header("myHeader");
+----
+
+== Dependencies
+
+The Header language is part of *camel-core*.
diff --git a/docs/components/modules/languages/pages/ref-language.adoc b/docs/components/modules/languages/pages/ref-language.adoc
new file mode 100644
index 0000000..7049275
--- /dev/null
+++ b/docs/components/modules/languages/pages/ref-language.adoc
@@ -0,0 +1,64 @@
+[[ref-language]]
+= Ref Language
+//THIS FILE IS COPIED: EDIT THE SOURCE FILE:
+:page-source: core/camel-core-languages/src/main/docs/modules/languages/pages/ref-language.adoc
+:docTitle: Ref
+:artifactId: camel-core-languages
+:description: Look up an expression in the Camel Registry and evaluate it.
+:since: 2.8
+:supportLevel: Stable
+
+*Since Camel {since}*
+
+The Ref Expression Language is really just a way to lookup a custom
+Expression or Predicate from the Registry.
+
+This is particular useable in XML DSLs.
+
+== Ref Language options
+
+// language options: START
+The Ref language supports 1 options, which are listed below.
+
+
+
+[width="100%",cols="2,1m,1m,6",options="header"]
+|===
+| Name | Default | Java Type | Description
+| trim | true | Boolean | Whether to trim the value to remove leading and trailing whitespaces and line breaks
+|===
+// language options: END
+
+== Example usage
+
+The Splitter in XML DSL can utilize a custom
+expression using `<ref>` like:
+
+[source,xml]
+----
+<bean id="myExpression" class="com.mycompany.MyCustomExpression"/>
+
+<route>
+ <from uri="seda:a"/>
+ <split>
+ <ref>myExpression</ref>
+ <to uri="mock:b"/>
+ </split>
+</route>
+----
+
+in this case, the Message coming from the seda:a
+Endpoint will be splitted using a custom
+Expression which has the id `myExpression` in the
+Registry.
+
+And the same example using Java DSL:
+
+[source,java]
+----
+from("seda:a").split().ref("myExpression").to("seda:b");
+----
+
+== Dependencies
+
+The Ref language is part of *camel-core*.
diff --git a/docs/components/modules/languages/pages/simple-language.adoc b/docs/components/modules/languages/pages/simple-language.adoc
new file mode 100644
index 0000000..316956a
--- /dev/null
+++ b/docs/components/modules/languages/pages/simple-language.adoc
@@ -0,0 +1,883 @@
+[[simple-language]]
+= Simple Language
+//THIS FILE IS COPIED: EDIT THE SOURCE FILE:
+:page-source: core/camel-core-languages/src/main/docs/modules/languages/pages/simple-language.adoc
+:docTitle: Simple
+:artifactId: camel-core-languages
+:description: Evaluate Camel's built-in Simple language expression against the Camel Exchange.
+:since: 1.1
+:supportLevel: Stable
+
+*Since Camel {since}*
+
+The Simple Expression Language was a really simple language when it was
+created, but has since grown more powerful. It is primarily intended for
+being a really small and simple language for evaluating
+Expressions and Predicates
+without requiring any new dependencies or knowledge of
+xref:xpath-language.adoc[XPath]; so it is ideal for testing in camel-core. The
+idea was to cover 95% of the common use cases when you need a little bit
+of expression based script in your Camel routes.
+
+However for much more complex use cases you are generally recommended to
+choose a more expressive and powerful language such as:
+
+* xref:groovy-language.adoc[Groovy]
+* xref:spel-language.adoc[SpEL]
+* xref:mvel-language.adoc[MVEL]
+* xref:ognl-language.adoc[OGNL]
+
+The simple language uses `${body`} placeholders for complex expressions or functions.
+
+[TIP]
+====
+*Alternative syntax*
+
+You can also use the alternative syntax which
+uses `$simple{ }` as placeholders. This can be used in situations to avoid clashes when using for example
+Spring property placeholder together with Camel.
+====
+
+== Simple Language options
+
+// language options: START
+The Simple language supports 2 options, which are listed below.
+
+
+
+[width="100%",cols="2,1m,1m,6",options="header"]
+|===
+| Name | Default | Java Type | Description
+| resultType | | String | Sets the class name of the result type (type from output)
+| trim | true | Boolean | Whether to trim the value to remove leading and trailing whitespaces and line breaks
+|===
+// language options: END
+
+== Variables
+
+[width="100%",cols="10%,10%,80%",options="header",]
+|=======================================================================
+|Variable |Type |Description
+
+|camelId |String |the CamelContext name
+
+|camelContext.*OGNL* |Object |the CamelContext invoked using a Camel OGNL expression.
+
+|exchange |Exchange |the Exchange
+
+|exchange.*OGNL* |Object |the Exchange invoked using a Camel
+OGNL expression.
+
+|exchangeId |String |the exchange id
+
+|id |String |the input message id
+
+|body |Object |the input body
+
+|in.body |Object |*deprecated* the input body
+
+|body.*OGNL* |Object |the input body invoked using a Camel OGNL expression.
+
+|in.body.*OGNL* |Object |*deprecated* the input body invoked using a Camel OGNL expression.
+
+|bodyAs(_type_) |Type |Converts the body to the given type determined by its
+classname. The converted body can be null.
+
+|bodyAs(_type_).*OGNL* |Object |Converts the body to the given type determined by its
+classname and then invoke methods using a Camel OGNL expression. The
+converted body can be null.
+
+|bodyOneLine | String | Converts the body to a String and removes all line-breaks so the string is in one line.
+
+|mandatoryBodyAs(_type_) |Type |Converts the body to the given type determined by its
+classname, and expects the body to be not null.
+
+|mandatoryBodyAs(_type_).*OGNL* |Object |Converts the body to the given type determined by its
+classname and then invoke methods using a Camel OGNL expression.
+
+|header.foo |Object |refer to the input foo header
+
+|header:foo |Object |refer to the input foo header
+
+|header[foo] |Object |refer to the input foo header
+
+|headers.foo |Object |refer to the input foo header
+
+|headers:foo |Object |refer to the input foo header
+
+|headers[foo] |Object |refer to the input foo header
+
+|in.header.foo |Object |*deprecated* refer to the input foo header
+
+|in.header:foo |Object |*deprecated* refer to the input foo header
+
+|in.header[foo] |Object |*deprecated* refer to the input foo header
+
+|in.headers.foo |Object |*deprecated* refer to the input foo header
+
+|in.headers:foo |Object |*deprecated* refer to the input foo header
+
+|in.headers[foo] |Object |*deprecated* refer to the input foo header
+
+|header.foo[bar] |Object |regard input foo header as a map and perform lookup on the
+map with bar as key
+
+|in.header.foo[bar] |Object |*deprecated* regard input foo header as a map and perform lookup on the
+map with bar as key
+
+|in.headers.foo[bar] |Object |*deprecated* regard input foo header as a map and perform lookup on the
+map with bar as key
+
+|header.foo.*OGNL* |Object |refer to the input foo header and invoke its value using a
+Camel OGNL expression.
+
+|in.header.foo.*OGNL* |Object |*deprecated* refer to the input foo header and invoke its value using a
+Camel OGNL expression.
+
+|in.headers.foo.*OGNL* |Object |*deprecated* refer to the input foo header and invoke its value using a
+Camel OGNL expression.
+
+|headerAs(_key_,_type_) |Type |converts the header to the given type determined by its
+classname
+
+|headers |Map |refer to the input headers
+
+|in.headers |Map |*deprecated* refer to the input headers
+
+|exchangeProperty.foo |Object |refer to the foo property on the exchange
+
+|exchangeProperty[foo] |Object |refer to the foo property on the exchange
+
+|exchangeProperty.foo.*OGNL* |Object |refer to the foo property on the exchange and invoke its
+value using a Camel OGNL expression.
+
+|sys.foo |String |refer to the JVM system property
+
+|sysenv.foo |String |refer to the system environment variable
+
+|env.foo |String |refer to the system environment variable
+
+|exception |Object |refer to the exception object on the exchange, is *null* if
+no exception set on exchange. Will fallback and grab caught exceptions
+(`Exchange.EXCEPTION_CAUGHT`) if the Exchange has any.
+
+|exception.*OGNL* |Object |refer to the exchange exception invoked using a Camel OGNL
+expression object
+
+|exception.message |String |refer to the exception.message on the exchange, is *null* if no
+exception set on exchange. Will fallback and grab caught exceptions
+(`Exchange.EXCEPTION_CAUGHT`) if the Exchange has any.
+
+|exception.stacktrace |String |refer to the exception.stracktrace on the exchange, is
+*null* if no exception set on exchange. Will fallback and grab caught
+exceptions (`Exchange.EXCEPTION_CAUGHT`) if the Exchange has any.
+
+|date:_command_ |Date |evaluates to a Date object.
+Supported commands are: *now* for current timestamp,
+*exchangeCreated* for the timestamp when the current exchange was created,
+*header.xxx* to use the Long/Date object header with the key xxx.
+*exchangeProperty.xxx* to use the Long/Date object in the exchange property with the key xxx.
+*file* for the last modified timestamp of the file (available with a File consumer).
+Command accepts offsets such as: *now-24h* or *header.xxx+1h* or even *now+1h30m-100*.
+
+|date:_command:pattern_ |String |Date formatting using `java.text.SimpleDateFormat` patterns.
+
+|date-with-timezone:_command:timezone:pattern_ |String |Date formatting using `java.text.SimpleDateFormat` timezones and patterns.
+
+|bean:_bean expression_ |Object |Invoking a bean expression using the xref:components::bean-component.adoc[Bean] language.
+Specifying a method name you must use dot as separator. We also support
+the ?method=methodname syntax that is used by the xref:components::bean-component.adoc[Bean]
+component. Camel will by default lookup a bean by the given name. However if you need to refer
+to a bean class (such as calling a static method) then you can prefix with type, such as `bean:type:fqnClassName`.
+
+|`properties:key:default` |String |Lookup a property with the given key. If the key does
+not exists or has no value, then an optional default value can be
+specified.
+
+|routeId |String |Returns the id of the current route the
+Exchange is being routed.
+
+|stepId |String |Returns the id of the current step the
+Exchange is being routed.
+
+|threadName |String |Returns the name of the current thread. Can be used for
+logging purpose.
+
+|hostname |String |Returns the local hostname (may be empty if not possible to resolve).
+
+|ref:xxx |Object |To lookup a bean from the Registry with
+the given id.
+
+|type:name.field |Object |To refer to a type or field by its FQN name. To refer to a
+field you can append .FIELD_NAME. For example you can refer to the
+constant field from Exchange as: `org.apache.camel.Exchange.FILE_NAME`
+
+|null |null |represents a *null*
+
+|random_(value)_ |Integer |returns a random Integer between 0 (included) and _value_
+(excluded)
+
+|random_(min,max)_ |Integer |returns a random Integer between _min_ (included) and
+_max_ (excluded)
+
+|collate(group) |List |The collate function iterates the message body and groups
+the data into sub lists of specified size. This can be used with the
+Splitter EIP to split a message body and group/batch
+the splitted sub message into a group of N sub lists. This method works
+similar to the collate method in Groovy.
+
+|skip(number) |Iterator |The skip function iterates the message body and skips
+the first number of items. This can be used with the
+Splitter EIP to split a message body and skip the first N number of items.
+
+|messageHistory |String |The message history of the current exchange how it has
+been routed. This is similar to the route stack-trace message history
+the error handler logs in case of an unhandled exception.
+
+|messageHistory(false) |String |As messageHistory but without the exchange details (only
+includes the route strack-trace). This can be used if you do not want to
+log sensitive data from the message itself.
+|=======================================================================
+
+== OGNL expression support
+
+INFO:Camel's OGNL support is for invoking methods only. You cannot access
+fields. Camel support accessing the length field of Java arrays.
+
+
+The xref:simple-language.adoc[Simple] and xref:simple-language.adoc[Bean] language now
+supports a Camel OGNL notation for invoking beans in a chain like
+fashion. Suppose the Message IN body contains a POJO which has a `getAddress()`
+method.
+
+Then you can use Camel OGNL notation to access the address object:
+
+[source,java]
+--------------------------------
+simple("${body.address}")
+simple("${body.address.street}")
+simple("${body.address.zip}")
+--------------------------------
+
+Camel understands the shorthand names for getters, but you can invoke
+any method or use the real name such as:
+
+[source,java]
+--------------------------------------
+simple("${body.address}")
+simple("${body.getAddress.getStreet}")
+simple("${body.address.getZip}")
+simple("${body.doSomething}")
+--------------------------------------
+
+You can also use the null safe operator (`?.`) to avoid NPE if for
+example the body does NOT have an address
+
+[source,java]
+----------------------------------
+simple("${body?.address?.street}")
+----------------------------------
+
+It is also possible to index in `Map` or `List` types, so you can do:
+
+[source,java]
+---------------------------
+simple("${body[foo].name}")
+---------------------------
+
+To assume the body is `Map` based and lookup the value with `foo` as
+key, and invoke the `getName` method on that value.
+
+If the key has space, then you *must* enclose the key with quotes, for
+example 'foo bar':
+
+[source,java]
+---------------------------------
+simple("${body['foo bar'].name}")
+---------------------------------
+
+You can access the `Map` or `List` objects directly using their key name
+(with or without dots) :
+
+[source,java]
+------------------------------
+simple("${body[foo]}")
+simple("${body[this.is.foo]}")
+------------------------------
+
+Suppose there was no value with the key `foo` then you can use the null
+safe operator to avoid the NPE as shown:
+
+[source,java]
+----------------------------
+simple("${body[foo]?.name}")
+----------------------------
+
+You can also access `List` types, for example to get lines from the
+address you can do:
+
+[source,java]
+----------------------------------
+simple("${body.address.lines[0]}")
+simple("${body.address.lines[1]}")
+simple("${body.address.lines[2]}")
+----------------------------------
+
+There is a special `last` keyword which can be used to get the last
+value from a list.
+
+[source,java]
+-------------------------------------
+simple("${body.address.lines[last]}")
+-------------------------------------
+
+And to get the 2nd last you can subtract a number, so we can use
+`last-1` to indicate this:
+
+[source,java]
+---------------------------------------
+simple("${body.address.lines[last-1]}")
+---------------------------------------
+
+And the 3rd last is of course:
+
+[source,java]
+---------------------------------------
+simple("${body.address.lines[last-2]}")
+---------------------------------------
+
+And you can call the size method on the list with
+
+[source,java]
+------------------------------------
+simple("${body.address.lines.size}")
+------------------------------------
+
+Camel supports the length field for Java arrays as well, eg:
+
+[source,java]
+---------------------------------------------------
+String[] lines = new String[]{"foo", "bar", "cat"};
+exchange.getIn().setBody(lines);
+
+simple("There are ${body.length} lines")
+---------------------------------------------------
+
+And yes you can combine this with the operator support as shown below:
+
+[source,java]
+------------------------------------
+simple("${body.address.zip} > 1000")
+------------------------------------
+
+== Operator support
+
+The parser is limited to only support a single operator.
+
+To enable it the left value must be enclosed in $\{ }. The syntax is:
+
+[source]
+--------------------------
+${leftValue} OP rightValue
+--------------------------
+
+Where the `rightValue` can be a String literal enclosed in `' '`,
+`null`, a constant value or another expression enclosed in $\{ }.
+
+IMPORTANT: There *must* be spaces around the operator.
+
+Camel will automatically type convert the rightValue type to the
+leftValue type, so it is able to eg. convert a string into a numeric so
+you can use > comparison for numeric values.
+
+The following operators are supported:
+
+[width="100%",cols="50%,50%",options="header",]
+|===
+|Operator |Description
+
+|== |equals
+
+|=~ |equals ignore case (will ignore case when comparing String values)
+
+|> |greater than
+
+|>= |greater than or equals
+
+|< |less than
+
+|<= |less than or equals
+
+|!= |not equals
+
+|!=~ |not equals ignore case (will ignore case when comparing String values)
+
+|contains |For testing if contains in a string based value
+
+|!contains |For testing if not contains in a string based value
+
+|~~ |For testing if contains by ignoring case sensitivity in a string based value
+
+|!~~ |For testing if not contains by ignoring case sensitivity in a string based value
+
+|regex |For matching against a given regular expression pattern defined as a
+String value
+
+|!regex |For not matching against a given regular expression pattern defined as a
+String value
+
+|in |For matching if in a set of values, each element must be separated by
+comma. If you want to include an empty value, then it must be defined using double comma, eg ',,bronze,silver,gold', which
+is a set of four values with an empty value and then the three medals.
+
+|!in |For matching if not in a set of values, each element must be separated
+by comma. If you want to include an empty value, then it must be defined using double comma, eg ',,bronze,silver,gold', which
+is a set of four values with an empty value and then the three medals.
+
+|is |For matching if the left hand side type is an instanceof the value.
+
+|!is |For matching if the left hand side type is not an instanceof the value.
+
+|range |For matching if the left hand side is within a range of values defined
+as numbers: `from..to`..
+
+|!range |For matching if the left hand side is not within a range of values
+defined as numbers: `from..to`. .
+
+|startsWith |For testing if the left hand side string starts
+with the right hand string.
+
+|starts with |Same as the startsWith operator.
+
+|endsWith |For testing if the left hand side string ends with
+the right hand string.
+
+|ends with |Same as the endsWith operator.
+|===
+
+And the following unary operators can be used:
+
+[width="100%",cols="50%,50%",options="header",]
+|===
+|Operator |Description
+
+|++ |To increment a number by one. The left hand side must be a
+function, otherwise parsed as literal.
+
+|-- |To decrement a number by one. The left hand side must be a
+function, otherwise parsed as literal.
+
+|\ |To escape a value, eg \$, to indicate a $ sign.
+Special: Use \n for new line, \t for tab, and \r for carriage return.
+*Notice:* Escaping is *not* supported using the
+xref:file-language.adoc[File Language]. *Notice:* The escape character is not supported, use the
+following three special escaping instead.
+
+|\n |To use newline character.
+
+|\t |To use tab character.
+
+|\r |To use carriage return character.
+
+|\} |To use the } character as text
+|===
+
+And the following logical operators can be used to group expressions:
+
+[width="100%",cols="50%,50%",options="header",]
+|===
+|Operator |Description
+
+|&& |The logical and operator is used to group two expressions.
+
+| \|\| |The logical or operator is used to group two expressions.
+|===
+
+The syntax for AND is:
+
+[source]
+----------------------------------------------------------
+${leftValue} OP rightValue && ${leftValue} OP rightValue
+----------------------------------------------------------
+
+And the syntax for OR is:
+
+[source]
+---------------------------------------------------------
+${leftValue} OP rightValue || ${leftValue} OP rightValue
+---------------------------------------------------------
+
+Some examples:
+
+[source,java]
+----
+// exact equals match
+simple("${in.header.foo} == 'foo'")
+
+// ignore case when comparing, so if the header has value FOO this will match
+simple("${in.header.foo} =~ 'foo'")
+
+// here Camel will type convert '100' into the type of in.header.bar and if it is an Integer '100' will also be converter to an Integer
+simple("${in.header.bar} == '100'")
+
+simple("${in.header.bar} == 100")
+
+// 100 will be converter to the type of in.header.bar so we can do > comparison
+simple("${in.header.bar} > 100")
+----
+
+=== Comparing with different types
+
+When you compare with different types such as String and int, then you
+have to take a bit care. Camel will use the type from the left hand side
+as 1st priority. And fallback to the right hand side type if both values
+couldn't be compared based on that type. +
+ This means you can flip the values to enforce a specific type. Suppose
+the bar value above is a String. Then you can flip the equation:
+
+[source,java]
+----
+simple("100 < ${in.header.bar}")
+----
+
+which then ensures the int type is used as 1st priority.
+
+This may change in the future if the Camel team improves the binary
+comparison operations to prefer numeric types over String based. It's
+most often the String type which causes problem when comparing with
+numbers.
+
+[source,java]
+----
+// testing for null
+simple("${in.header.baz} == null")
+
+// testing for not null
+simple("${in.header.baz} != null")
+----
+
+And a bit more advanced example where the right value is another
+expression
+
+[source,java]
+----
+simple("${in.header.date} == ${date:now:yyyyMMdd}")
+
+simple("${in.header.type} == ${bean:orderService?method=getOrderType}")
+----
+
+And an example with contains, testing if the title contains the word
+Camel
+
+[source,java]
+----
+simple("${in.header.title} contains 'Camel'")
+----
+
+And an example with regex, testing if the number header is a 4 digit
+value:
+
+[source,java]
+----
+simple("${in.header.number} regex '\\d{4}'")
+----
+
+And finally an example if the header equals any of the values in the
+list. Each element must be separated by comma, and no space around. +
+ This also works for numbers etc, as Camel will convert each element
+into the type of the left hand side.
+
+[source,java]
+----
+simple("${in.header.type} in 'gold,silver'")
+----
+
+And for all the last 3 we also support the negate test using not:
+
+[source,java]
+----
+simple("${in.header.type} !in 'gold,silver'")
+----
+
+And you can test if the type is a certain instance, eg for instance a
+String
+
+[source,java]
+----
+simple("${in.header.type} is 'java.lang.String'")
+----
+
+We have added a shorthand for all `java.lang` types so you can write it
+as:
+
+[source,java]
+----
+simple("${in.header.type} is 'String'")
+----
+
+Ranges are also supported. The range interval requires numbers and both
+from and end are inclusive. For instance to test whether a value is
+between 100 and 199:
+
+[source,java]
+----
+simple("${in.header.number} range 100..199")
+----
+
+Notice we use `..` in the range without spaces. It is based on the same
+syntax as Groovy.
+
+From *Camel 2.9* onwards the range value must be in single quotes
+
+[source,java]
+----
+simple("${in.header.number} range '100..199'")
+----
+
+=== Using Spring XML
+
+As the Spring XML does not have all the power as the Java DSL with all
+its various builder methods, you have to resort to use some other
+languages for testing with simple operators. Now you can do this with the simple
+language. In the sample below we want to test if the header is a widget
+order:
+
+[source,xml]
+----
+<from uri="seda:orders">
+ <filter>
+ <simple>${in.header.type} == 'widget'</simple>
+ <to uri="bean:orderService?method=handleWidget"/>
+ </filter>
+</from>
+----
+
+== Using and / or
+
+If you have two expressions you can combine them with the `&&` or `||`
+operator.
+
+For instance:
+
+[source,java]
+-----
+simple("${in.header.title} contains 'Camel' && ${in.header.type'} == 'gold'")
+-----
+
+And of course the `||` is also supported. The sample would be:
+
+[source,java]
+-----
+simple("${in.header.title} contains 'Camel' || ${in.header.type'} == 'gold'")
+-----
+
+== Samples
+
+In the Spring XML sample below we filter based on a header value:
+
+[source,xml]
+--------------------------------------------
+<from uri="seda:orders">
+ <filter>
+ <simple>${in.header.foo}</simple>
+ <to uri="mock:fooOrders"/>
+ </filter>
+</from>
+--------------------------------------------
+
+The Simple language can be used for the predicate test above in the
+Message Filter pattern, where we test if the
+in message has a `foo` header (a header with the key `foo` exists). If
+the expression evaluates to *true* then the message is routed to the
+`mock:fooOrders` endpoint, otherwise the message is dropped.
+
+The same example in Java DSL:
+
+[source,java]
+----
+from("seda:orders")
+ .filter().simple("${in.header.foo}")
+ .to("seda:fooOrders");
+----
+
+You can also use the simple language for simple text concatenations such
+as:
+
+[source,java]
+----
+from("direct:hello")
+ .transform().simple("Hello ${in.header.user} how are you?")
+ .to("mock:reply");
+----
+
+Notice that we must use $\{ } placeholders in the expression now to
+allow Camel to parse it correctly.
+
+And this sample uses the date command to output current date.
+
+[source,java]
+----
+from("direct:hello")
+ .transform().simple("The today is ${date:now:yyyyMMdd} and it is a great day.")
+ .to("mock:reply");
+----
+
+And in the sample below we invoke the bean language to invoke a method
+on a bean to be included in the returned string:
+
+[source,java]
+----
+from("direct:order")
+ .transform().simple("OrderId: ${bean:orderIdGenerator}")
+ .to("mock:reply");
+----
+
+Where `orderIdGenerator` is the id of the bean registered in the
+Registry. If using Spring then it is the Spring bean
+id.
+
+If we want to declare which method to invoke on the order id generator
+bean we must prepend `.method name` such as below where we invoke the
+`generateId` method.
+
+[source,java]
+----
+from("direct:order")
+ .transform().simple("OrderId: ${bean:orderIdGenerator.generateId}")
+ .to("mock:reply");
+----
+
+We can use the `?method=methodname` option that we are familiar with the
+xref:components::bean-component.adoc[Bean] component itself:
+
+[source,java]
+----
+from("direct:order")
+ .transform().simple("OrderId: ${bean:orderIdGenerator?method=generateId}")
+ .to("mock:reply");
+----
+
+You can also convert the body to a given
+type, for example to ensure that it is a String you can do:
+
+[source,xml]
+----
+<transform>
+ <simple>Hello ${bodyAs(String)} how are you?</simple>
+</transform>
+----
+
+There are a few types which have a shorthand notation, so we can use
+`String` instead of `java.lang.String`. These are:
+`byte[], String, Integer, Long`. All other types must use their FQN
+name, e.g. `org.w3c.dom.Document`.
+
+It is also possible to lookup a value from a header `Map`:
+
+[source,xml]
+----
+<transform>
+ <simple>The gold value is ${header.type[gold]}</simple>
+</transform>
+----
+
+In the code above we lookup the header with name `type` and regard it as
+a `java.util.Map` and we then lookup with the key `gold` and return the
+value. If the header is not convertible to Map an exception is thrown. If the
+header with name `type` does not exist `null` is returned.
+
+You can nest functions, such as shown below:
+
+[source,xml]
+----
+<setHeader name="myHeader">
+ <simple>${properties:${header.someKey}}</simple>
+</setHeader>
+----
+
+== Referring to constants or enums
+
+Suppose you have an enum for customers
+
+And in a Content Based Router we can use
+the xref:simple-language.adoc[Simple] language to refer to this enum, to check
+the message which enum it matches.
+
+== Using new lines or tabs in XML DSLs
+
+It is easier to specify new lines or tabs in
+XML DSLs as you can escape the value now
+
+[source,xml]
+----
+<transform>
+ <simple>The following text\nis on a new line</simple>
+</transform>
+----
+
+== Leading and trailing whitespace handling
+
+The trim attribute of the expression can be
+used to control whether the leading and trailing whitespace characters
+are removed or preserved. The default value is true, which removes the
+whitespace characters.
+
+[source,xml]
+----
+<setBody>
+ <simple trim="false">You get some trailing whitespace characters. </simple>
+</setBody>
+----
+
+== Setting result type
+
+You can now provide a result type to the xref:simple-language.adoc[Simple]
+expression, which means the result of the evaluation will be converted
+to the desired type. This is most usable to define types such as
+booleans, integers, etc.
+
+For example to set a header as a boolean type you can do:
+
+[source,java]
+----
+.setHeader("cool", simple("true", Boolean.class))
+----
+
+And in XML DSL
+
+[source,xml]
+----
+<setHeader name="cool">
+ <!-- use resultType to indicate that the type should be a java.lang.Boolean -->
+ <simple resultType="java.lang.Boolean">true</simple>
+</setHeader>
+----
+
+== Loading script from external resource
+
+You can externalize the script and have Camel load it from a resource
+such as `"classpath:"`, `"file:"`, or `"http:"`. +
+ This is done using the following syntax: `"resource:scheme:location"`,
+eg to refer to a file on the classpath you can do:
+
+[source,java]
+----
+.setHeader("myHeader").simple("resource:classpath:mysimple.txt")
+----
+
+== Setting Spring beans to Exchange properties
+
+You can set a spring bean into an exchange property as shown below:
+
+[source,xml]
+----
+<bean id="myBeanId" class="my.package.MyCustomClass" />
+...
+<route>
+ ...
+ <setProperty name="monitoring.message">
+ <simple>ref:myBeanId</simple>
+ </setProperty>
+ ...
+</route>
+----
diff --git a/docs/components/modules/languages/pages/tokenize-language.adoc b/docs/components/modules/languages/pages/tokenize-language.adoc
new file mode 100644
index 0000000..fd4a7b7
--- /dev/null
+++ b/docs/components/modules/languages/pages/tokenize-language.adoc
@@ -0,0 +1,46 @@
+[[tokenize-language]]
+= Tokenize Language
+//THIS FILE IS COPIED: EDIT THE SOURCE FILE:
+:page-source: core/camel-core-languages/src/main/docs/modules/languages/pages/tokenize-language.adoc
+:docTitle: Tokenize
+:artifactId: camel-core-languages
+:description: Tokenize text payloads using the specified delimiter patterns.
+:since: 2.0
+:supportLevel: Stable
+
+*Since Camel {since}*
+
+The tokenizer language is a built-in language in camel-core, which is
+most often used only with the Splitter EIP to split
+a message using a token-based strategy. +
+The tokenizer language is intended to tokenize text documents using a
+specified delimiter pattern. It can also be used to tokenize XML
+documents with some limited capability. For a truly XML-aware
+tokenization, the use of the XMLTokenizer
+language is recommended as it offers a faster, more efficient
+tokenization specifically for XML documents. For more details
+see Splitter.
+
+== Tokenize Options
+
+// language options: START
+The Tokenize language supports 11 options, which are listed below.
+
+
+
+[width="100%",cols="2,1m,1m,6",options="header"]
+|===
+| Name | Default | Java Type | Description
+| token | | String | The (start) token to use as tokenizer, for example you can use the new line token. You can use simple language as the token to support dynamic tokens.
+| endToken | | String | The end token to use as tokenizer if using start/end token pairs. You can use simple language as the token to support dynamic tokens.
+| inheritNamespaceTagName | | String | To inherit namespaces from a root/parent tag name when using XML You can use simple language as the tag name to support dynamic names.
+| headerName | | String | Name of header to tokenize instead of using the message body.
+| regex | false | Boolean | If the token is a regular expression pattern. The default value is false
+| xml | false | Boolean | Whether the input is XML messages. This option must be set to true if working with XML payloads.
+| includeTokens | false | Boolean | Whether to include the tokens in the parts when using pairs The default value is false
+| group | | String | To group N parts together, for example to split big files into chunks of 1000 lines. You can use simple language as the group to support dynamic group sizes.
+| groupDelimiter | | String | Sets the delimiter to use when grouping. If this has not been set then token will be used as the delimiter.
+| skipFirst | false | Boolean | To skip the very first element
+| trim | true | Boolean | Whether to trim the value to remove leading and trailing whitespaces and line breaks
+|===
+// language options: END
diff --git a/docs/components/modules/languages/pages/xtokenize-language.adoc b/docs/components/modules/languages/pages/xtokenize-language.adoc
new file mode 100644
index 0000000..0c43e3e
--- /dev/null
+++ b/docs/components/modules/languages/pages/xtokenize-language.adoc
@@ -0,0 +1,38 @@
+[[xtokenize-language]]
+= XML Tokenize Language
+//THIS FILE IS COPIED: EDIT THE SOURCE FILE:
+:page-source: core/camel-xml-jaxp/src/main/docs/modules/languages/pages/xtokenize-language.adoc
+:docTitle: XML Tokenize
+:artifactId: camel-xml-jaxp
+:description: Tokenize XML payloads using the specified path expression.
+:since: 2.14
+:supportLevel: Stable
+
+*Since Camel {since}*
+
+The xml tokenizer language is a built-in language in camel-core, which
+is a truly XML-aware tokenizer that can be used with the Splitter as the
+conventional Tokenizer to efficiently and
+effectively tokenize XML documents. XMLTokenizer is capable of not only
+recognizing XML namespaces and hierarchical structures of the document
+but also more efficiently tokenizing XML documents than the conventional
+Tokenizer.
+
+For more details see Splitter.
+
+== XML Tokenizer Options
+
+// language options: START
+The XML Tokenize language supports 4 options, which are listed below.
+
+
+
+[width="100%",cols="2,1m,1m,6",options="header"]
+|===
+| Name | Default | Java Type | Description
+| headerName | | String | Name of header to tokenize instead of using the message body.
+| mode | | String | The extraction mode. The available extraction modes are: i - injecting the contextual namespace bindings into the extracted token (default) w - wrapping the extracted token in its ancestor context u - unwrapping the extracted token to its child content t - extracting the text content of the specified element
+| group | | Integer | To group N parts together
+| trim | true | Boolean | Whether to trim the value to remove leading and trailing whitespaces and line breaks
+|===
+// language options: END
diff --git a/docs/gulpfile.js b/docs/gulpfile.js
index 7bf17da..4a6fe0b 100644
--- a/docs/gulpfile.js
+++ b/docs/gulpfile.js
@@ -324,8 +324,6 @@ function createComponentLanguagesNav () {
inject(
src([
'components/modules/languages/pages/**/*.adoc',
- '../core/camel-core-languages/src/main/docs/modules/languages/pages/*.adoc',
- '../core/camel-xml-jaxp/src/main/docs/modules/languages/pages/*.adoc',
'!components/modules/languages/pages/index.adoc',
]).pipe(sort(compare)),
{
diff --git a/tooling/maven/camel-package-maven-plugin/src/main/java/org/apache/camel/maven/packaging/PrepareComponentMojo.java b/tooling/maven/camel-package-maven-plugin/src/main/java/org/apache/camel/maven/packaging/PrepareComponentMojo.java
index 4a842a8..5c6930d 100644
--- a/tooling/maven/camel-package-maven-plugin/src/main/java/org/apache/camel/maven/packaging/PrepareComponentMojo.java
+++ b/tooling/maven/camel-package-maven-plugin/src/main/java/org/apache/camel/maven/packaging/PrepareComponentMojo.java
@@ -20,6 +20,7 @@ import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
+import java.util.Objects;
import java.util.TreeSet;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
@@ -145,6 +146,13 @@ public class PrepareComponentMojo extends AbstractGeneratorMojo {
// whether to sync pom
Object val = project.getContextValue("syncPomFile");
+ if (val != null) {
+ File parent = project.getBasedir().getParentFile();
+ File components = findCamelDirectory(project.getBasedir(), "components");
+ if (Objects.equals(parent, components)) {
+ val = false;
+ }
+ }
// Update all component pom sync point
if (count > 0 && (val == null || val.equals("true"))) {