From 66d91fab0154bc2117c549d70bbb9d1ecede55a7 Mon Sep 17 00:00:00 2001
From: Clement Escoffier <clement.escoffier@gmail.com>
Date: Tue, 25 Jun 2019 14:14:02 +0200
Subject: [PATCH 1/7] Small improvements in the Javadoc

* provide a package-info for the SPI package
* remove outdated content from the Acknowledgement class
* Fix link to DeploymentException in the OutgoingConnectorFactory
* Fix capitalization in the Connector `value` method

Signed-off-by: Clement Escoffier <clement.escoffier@gmail.com>
---
 .../reactive/messaging/Acknowledgment.java    | 51 ++++---------------
 .../reactive/messaging/spi/Connector.java     |  2 +-
 .../spi/OutgoingConnectorFactory.java         |  5 +-
 .../reactive/messaging/spi/package-info.java  | 42 +++++++++++++++
 4 files changed, 57 insertions(+), 43 deletions(-)
 create mode 100644 api/src/main/java/org/eclipse/microprofile/reactive/messaging/spi/package-info.java

diff --git a/api/src/main/java/org/eclipse/microprofile/reactive/messaging/Acknowledgment.java b/api/src/main/java/org/eclipse/microprofile/reactive/messaging/Acknowledgment.java
index 898e6875..e312e6ea 100644
--- a/api/src/main/java/org/eclipse/microprofile/reactive/messaging/Acknowledgment.java
+++ b/api/src/main/java/org/eclipse/microprofile/reactive/messaging/Acknowledgment.java
@@ -24,45 +24,15 @@
 /**
  * Configure the acknowledgement policy for the given {@code @Incoming}.
  *
- * The set of supported acknowledgment policy depends on the method signature. The given list indicates the supported
- * policies for each type of signature:
+ * The set of supported acknowledgment policy depends on the method signature. The following list gives the supported
+ * strategies for some common use cases.
+ * Please refer to the specification document to check the full list.
  *
  * <ul>
- *     <li><code>@Incoming Subscriber&lt;Message&lt;I&gt;&gt; method()</code>: None, Pre, Manual</li>
- *     <li><code>@Incoming Subscriber&lt;I&gt; method()</code>: None, Pre, Post</li>
- *     <li><code>@Incoming void method(I msg)</code>: None, Pre, Post</li>
- *     <li><code>@Incoming CompletionStage&lt;?&gt; method(Message&lt;I&gt; msg)</code>: None, Pre, Post, Manual</li>
- *     <li><code>@Incoming CompletionStage&lt;?&gt; method(I msg)</code>: None, Pre, Post</li>
- *
- *     <li><code>@Outgoing @Incoming Processor&lt;Message&lt;I&gt;, Message&lt;O&gt;&gt; method()</code>: None, Pre,
- *     Manual, Post with the assumption that each incoming message produces a single outgoing message</li>
- *     <li><code>@Outgoing @Incoming Processor&lt;I, O&gt; method()</code>: None, Pre, Post with the assumption
- *     that each incoming payload produces a single outgoing payload</li>
- *     <li><code>@Outgoing @Incoming ProcessorBuilder&lt;Message&lt;I&gt;, Message&lt;O&gt;&gt; method()</code>: None,
- *     Manual, Pre, Post with the assumption that each incoming message produces a single outgoing message</li>
- *     <li><code>@Outgoing @Incoming ProcessorBuilder&lt;I, O&gt; method()</code>: None, Manual, Pre, Post with the
- *     assumption that each incoming payload produces a single outgoing payload</li>
- *
- *     <li><code>@Outgoing @Incoming Publisher&lt;Message&lt;O&gt;&gt; method(Message&lt;I&gt; msg)</code>: None,
- *     Manual,Pre</li>
- *     <li><code>@Outgoing @Incoming Publisher&lt;O&gt; method(I payload)</code>: None, Pre</li>
- *     <li><code>@Outgoing @Incoming PublisherBuilder&lt;Message&lt;O&gt;&gt; method(Message&lt;I&gt; msg)</code>: None,
- *     Pre, Manual</li>
- *     <li><code>@Outgoing @Incoming PublisherBuilder&lt;O&gt; method(I payload)</code>: None, Pre</li>
- *
- *     <li><code>@Outgoing @Incoming Message&lt;O&gt; method(Message&lt;I&gt; msg)</code>: None, Manual, Pre, Post</li>
- *     <li><code>@Outgoing @Incoming O method(I payload)</code>: None, Pre, Post</li>
- *     <li><code>@Outgoing @Incoming CompletionStage&lt;Message&lt;O&gt;&gt; method(Message&lt;I&gt; msg)</code>: None,
- *     Manual, Pre, Post</li>
- *     <li><code>@Outgoing @Incoming CompletionStage&lt;O&gt; method(I msg)</code>: None, Pre, Post</li>
- *
- *     <li><code>@Outgoing @Incoming Publisher&lt;Message&lt;O&gt;&gt; method(Publisher&lt;Message&lt;I&gt;&gt; pub)
- *     </code>: None, Manual, Pre</li>
- *     <li><code>@Outgoing @Incoming Publisher&lt;O&gt; method(Publisher&lt;I&gt; pub)</code>: None, Pre</li>
- *     <li><code>@Outgoing @Incoming PublisherBuilder&lt;Message&lt;O&gt;&gt; method(PublisherBuilder&lt;Message&lt;I&gt;&gt; pub)
- *     </code>: None, Manual, Pre</li>
- *     <li><code>@Outgoing @Incoming PublisherBuilder&lt;O&gt; method(PublisherBuilder&lt;I&gt; pub)</code>: None, Pre
- *     </li>
+ *     <li><code> @Incoming("channel") void method(I payload)</code>: Post-processing (default), Pre-processing, None</li>
+ *     <li><code> @Incoming("channel") CompletionStage&lt;?&gt; method(I payload)</code>: Post-processing (default), Pre-processing, None</li>
+ *     <li><code> @Incoming("in") @Outgoing("out") Message&lt;O&gt; method(Message&lt;I&gt; msg)</code>: Pre-processing (default), None, Manual</li>
+ *     <li><code> @Incoming("in") @Outgoing("out") O method(I payload)</code>: Post-Processing (default), Pre-processing, None</li>
  * </ul>
  *
  */
@@ -87,10 +57,11 @@ enum Strategy {
     PRE_PROCESSING,
 
     /**
-     * Acknowledgment performed automatically after the user processing of the message.
+     * Acknowledgment performed automatically after the processing of the message.
+     * When {@code POST_PROCESSING} is used, the incoming message is acknowledged when the produced message is
+     * acknowledged.
      *
-     * Notice that this mode is not supported for all signatures. check the list above.
-     * When supported it's the default policy.
+     * Notice that this mode is not supported for all signatures. When supported it's the default policy.
      *
      */
     POST_PROCESSING
diff --git a/api/src/main/java/org/eclipse/microprofile/reactive/messaging/spi/Connector.java b/api/src/main/java/org/eclipse/microprofile/reactive/messaging/spi/Connector.java
index 0525cf34..047bdf41 100644
--- a/api/src/main/java/org/eclipse/microprofile/reactive/messaging/spi/Connector.java
+++ b/api/src/main/java/org/eclipse/microprofile/reactive/messaging/spi/Connector.java
@@ -40,7 +40,7 @@
 public @interface Connector {
 
     /**
-     * @return the name of the connector associated with the bean implementing {@link IncomingConnectorFactory}
+     * @return The name of the connector associated with the bean implementing {@link IncomingConnectorFactory}
      * or {@link OutgoingConnectorFactory}. Must not be {@code null}. Returning {@code null} will cause a deployment
      * failure.
      */
diff --git a/api/src/main/java/org/eclipse/microprofile/reactive/messaging/spi/OutgoingConnectorFactory.java b/api/src/main/java/org/eclipse/microprofile/reactive/messaging/spi/OutgoingConnectorFactory.java
index 59697deb..75a0097c 100644
--- a/api/src/main/java/org/eclipse/microprofile/reactive/messaging/spi/OutgoingConnectorFactory.java
+++ b/api/src/main/java/org/eclipse/microprofile/reactive/messaging/spi/OutgoingConnectorFactory.java
@@ -21,6 +21,8 @@
 import org.eclipse.microprofile.config.Config;
 import org.eclipse.microprofile.reactive.messaging.Message;
 import org.eclipse.microprofile.reactive.streams.operators.SubscriberBuilder;
+import javax.enterprise.inject.spi.DeploymentException;
+
 
 import java.util.NoSuchElementException;
 
@@ -72,8 +74,7 @@
  * In the previous configuration, the reactive messaging implementation would need to find the
  * {@link OutgoingConnectorFactory} implementation qualified with the {@link Connector} qualifier with the value
  * {@code acme.kafka} to create the {@code my-channel} <em>subscriber</em>. Note that if
- * the connector cannot be found, the deployment must be failed with a
- * {@link javax.enterprise.inject.spi.DeploymentException}.
+ * the connector cannot be found, the deployment must be failed with a {@link DeploymentException}.
  * <p>
  * The {@link #getSubscriberBuilder(Config)} is called for every <em>channel</em> that needs to be created. The
  * {@link Config} object passed to the method contains a subset of the global configuration, and with the prefixes removed.
diff --git a/api/src/main/java/org/eclipse/microprofile/reactive/messaging/spi/package-info.java b/api/src/main/java/org/eclipse/microprofile/reactive/messaging/spi/package-info.java
new file mode 100644
index 00000000..497a11f6
--- /dev/null
+++ b/api/src/main/java/org/eclipse/microprofile/reactive/messaging/spi/package-info.java
@@ -0,0 +1,42 @@
+/**
+ * Copyright (c) 2018-2019 Contributors to the Eclipse Foundation
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information regarding copyright ownership.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * You may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * The MicroProfile Reactive Messaging API Connector SPI
+ * <p>
+ * This package provides the SPI to implement {@code connector}. A {@code connector} can be seen as a Reactive Messaging
+ * plug-in to support a specific messaging technology. For example, you can have a Kafka connector to deal with Kafka,
+ * an AMQP connector to deal interact with AMQP brokers and routers and so on. Connector implementation should be
+ * agnostic to the Reactive Messaging implementation.
+ *
+ * A connector can be seen as:
+ * <ul>
+ *     <li>a source of messages - it retrieves messages and injects them into the Reactive Messaging application. To
+ *     manage this direction, the connector implementation must implement the
+ *     {@link org.eclipse.microprofile.reactive.messaging.spi.IncomingConnectorFactory} interface.</li>
+ *     <li>a sink of messages - it forwards messages emitted by the Reactive Messaging application to the managed
+ *     technology. To achieve this, the connector implementation must implement the
+ *     {@link org.eclipse.microprofile.reactive.messaging.spi.OutgoingConnectorFactory} interface.</li>
+ * </ul>
+ *
+ * Connectors are  implemented as CDI beans and identified using the
+ * {@link org.eclipse.microprofile.reactive.messaging.spi.Connector} qualifier. Connectors receive the channel
+ * configuration matching their {@link Connector} name.
+ */
+package org.eclipse.microprofile.reactive.messaging.spi;

From 0df3fe0cc1d000662d2ec7bf2d37882ede14084d Mon Sep 17 00:00:00 2001
From: Clement Escoffier <clement.escoffier@gmail.com>
Date: Wed, 26 Jun 2019 09:06:34 +0200
Subject: [PATCH 2/7] Configure the Maven Javadoc Plugin to create links to
 external dependencies (CDI, MicroProfile Config, MicroProfile Reactive
 Streams Operators). Avoid using import statement on DeploymentException, and
 use FQCN in the javadoc

Signed-off-by: Clement Escoffier <clement.escoffier@gmail.com>
---
 api/pom.xml                                            | 10 ++++++++++
 .../messaging/spi/IncomingConnectorFactory.java        |  5 ++---
 .../messaging/spi/OutgoingConnectorFactory.java        |  3 +--
 pom.xml                                                |  3 ++-
 4 files changed, 15 insertions(+), 6 deletions(-)

diff --git a/api/pom.xml b/api/pom.xml
index 41b7afc7..d6905d0f 100644
--- a/api/pom.xml
+++ b/api/pom.xml
@@ -67,6 +67,16 @@
                         </goals>
                     </execution>
                 </executions>
+                <configuration>
+                    <detectJavaApiLink>true</detectJavaApiLink>
+                    <detectOfflineLinks>true</detectOfflineLinks>
+                    <links>
+                        <link>https://docs.jboss.org/cdi/api/${cdi-api.version}/</link>
+                        <link>https://download.eclipse.org/microprofile/microprofile-reactive-streams-operators-${microprofile.reactive.streams.operators.version}/apidocs/</link>
+                        <link>https://download.eclipse.org/microprofile/microprofile-config-${microprofile-config-api.version}/apidocs/</link>
+                        <link>https://osgi.org/javadoc/r6/annotation/</link>
+                    </links>
+                </configuration>
             </plugin>
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
diff --git a/api/src/main/java/org/eclipse/microprofile/reactive/messaging/spi/IncomingConnectorFactory.java b/api/src/main/java/org/eclipse/microprofile/reactive/messaging/spi/IncomingConnectorFactory.java
index 5fc9772e..e6a37a26 100644
--- a/api/src/main/java/org/eclipse/microprofile/reactive/messaging/spi/IncomingConnectorFactory.java
+++ b/api/src/main/java/org/eclipse/microprofile/reactive/messaging/spi/IncomingConnectorFactory.java
@@ -22,7 +22,6 @@
 import org.eclipse.microprofile.reactive.messaging.Message;
 import org.eclipse.microprofile.reactive.streams.operators.PublisherBuilder;
 
-import javax.enterprise.inject.spi.DeploymentException;
 import java.util.NoSuchElementException;
 
 /**
@@ -75,7 +74,7 @@
  * In the previous configuration, the reactive messaging implementation would need to find the
  * {@link IncomingConnectorFactory} qualified using the {@link Connector} qualifier with the value
  * {@code acme.kafka} class to create the {@code my-channel} channel. Note that if the
- * connector cannot be found, the deployment must be failed with a {@link DeploymentException}.
+ * connector cannot be found, the deployment must be failed with a {@link javax.enterprise.inject.spi.DeploymentException}.
  * <p>
  * The {@link #getPublisherBuilder(Config)} is called for every channel that needs to be created. The {@link Config} object
  * passed to the method contains a subset of the global configuration, and with the prefixes removed. So for the previous
@@ -94,7 +93,7 @@
  * <p>
  * If the configuration is invalid, the {@link #getPublisherBuilder(Config)} method must throw an
  * {@link IllegalArgumentException}, caught by the reactive messaging implementation and failing the deployment by
- * throwing a {@link DeploymentException} wrapping the exception.
+ * throwing a {@link javax.enterprise.inject.spi.DeploymentException} wrapping the exception.
  * <p>
  * Note that a Reactive Messaging implementation must support the configuration format described here. Implementations
  * are free to provide additional support for other approaches.
diff --git a/api/src/main/java/org/eclipse/microprofile/reactive/messaging/spi/OutgoingConnectorFactory.java b/api/src/main/java/org/eclipse/microprofile/reactive/messaging/spi/OutgoingConnectorFactory.java
index 75a0097c..06350ea6 100644
--- a/api/src/main/java/org/eclipse/microprofile/reactive/messaging/spi/OutgoingConnectorFactory.java
+++ b/api/src/main/java/org/eclipse/microprofile/reactive/messaging/spi/OutgoingConnectorFactory.java
@@ -21,7 +21,6 @@
 import org.eclipse.microprofile.config.Config;
 import org.eclipse.microprofile.reactive.messaging.Message;
 import org.eclipse.microprofile.reactive.streams.operators.SubscriberBuilder;
-import javax.enterprise.inject.spi.DeploymentException;
 
 
 import java.util.NoSuchElementException;
@@ -74,7 +73,7 @@
  * In the previous configuration, the reactive messaging implementation would need to find the
  * {@link OutgoingConnectorFactory} implementation qualified with the {@link Connector} qualifier with the value
  * {@code acme.kafka} to create the {@code my-channel} <em>subscriber</em>. Note that if
- * the connector cannot be found, the deployment must be failed with a {@link DeploymentException}.
+ * the connector cannot be found, the deployment must be failed with a {@link javax.enterprise.inject.spi.DeploymentException}.
  * <p>
  * The {@link #getSubscriberBuilder(Config)} is called for every <em>channel</em> that needs to be created. The
  * {@link Config} object passed to the method contains a subset of the global configuration, and with the prefixes removed.
diff --git a/pom.xml b/pom.xml
index 83917266..60ff4b33 100644
--- a/pom.xml
+++ b/pom.xml
@@ -47,6 +47,7 @@
         <!-- keeping closed repos with failure - default is false because the errors are visible in the maven output, but true will leave the repo open for investigation in Sonatype Nexus -->
         <keepStagingReposOnFailure>false</keepStagingReposOnFailure>
         <microprofile-config-api.version>1.3</microprofile-config-api.version>
+        <cdi-api.version>2.0</cdi-api.version>
     </properties>
 
     <licenses>
@@ -168,7 +169,7 @@
             <dependency>
                 <groupId>javax.enterprise</groupId>
                 <artifactId>cdi-api</artifactId>
-                <version>2.0</version>
+                <version>${cdi-api.version}</version>
             </dependency>
             <dependency>
                 <groupId>javax.json.bind</groupId>

From d1ad68c60af8eddb8e4105ceda7ee3403340dca4 Mon Sep 17 00:00:00 2001
From: Clement Escoffier <clement.escoffier@gmail.com>
Date: Wed, 26 Jun 2019 09:10:06 +0200
Subject: [PATCH 3/7] Fix typos and a bit of rewording

Signed-off-by: Clement Escoffier <clement.escoffier@gmail.com>
---
 .../microprofile/reactive/messaging/Acknowledgment.java   | 8 ++++----
 .../microprofile/reactive/messaging/spi/package-info.java | 2 +-
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/api/src/main/java/org/eclipse/microprofile/reactive/messaging/Acknowledgment.java b/api/src/main/java/org/eclipse/microprofile/reactive/messaging/Acknowledgment.java
index e312e6ea..c972fe5d 100644
--- a/api/src/main/java/org/eclipse/microprofile/reactive/messaging/Acknowledgment.java
+++ b/api/src/main/java/org/eclipse/microprofile/reactive/messaging/Acknowledgment.java
@@ -24,9 +24,9 @@
 /**
  * Configure the acknowledgement policy for the given {@code @Incoming}.
  *
- * The set of supported acknowledgment policy depends on the method signature. The following list gives the supported
+ * The set of supported acknowledgment policies depends on the method signature. The following list gives the supported
  * strategies for some common use cases.
- * Please refer to the specification document to check the full list.
+ * Please refer to the specification for the full list.
  *
  * <ul>
  *     <li><code> @Incoming("channel") void method(I payload)</code>: Post-processing (default), Pre-processing, None</li>
@@ -57,11 +57,11 @@ enum Strategy {
     PRE_PROCESSING,
 
     /**
-     * Acknowledgment performed automatically after the processing of the message.
+     * Acknowledgment performed automatically after the message being processed.
      * When {@code POST_PROCESSING} is used, the incoming message is acknowledged when the produced message is
      * acknowledged.
      *
-     * Notice that this mode is not supported for all signatures. When supported it's the default policy.
+     * Notice that this mode is not supported for all signatures. When supported, it's the default policy.
      *
      */
     POST_PROCESSING
diff --git a/api/src/main/java/org/eclipse/microprofile/reactive/messaging/spi/package-info.java b/api/src/main/java/org/eclipse/microprofile/reactive/messaging/spi/package-info.java
index 497a11f6..bebfd4b2 100644
--- a/api/src/main/java/org/eclipse/microprofile/reactive/messaging/spi/package-info.java
+++ b/api/src/main/java/org/eclipse/microprofile/reactive/messaging/spi/package-info.java
@@ -22,7 +22,7 @@
  * <p>
  * This package provides the SPI to implement {@code connector}. A {@code connector} can be seen as a Reactive Messaging
  * plug-in to support a specific messaging technology. For example, you can have a Kafka connector to deal with Kafka,
- * an AMQP connector to deal interact with AMQP brokers and routers and so on. Connector implementation should be
+ * an AMQP connector to interact with AMQP brokers and routers and so on. Connector implementation should be
  * agnostic to the Reactive Messaging implementation.
  *
  * A connector can be seen as:

From b0651d8763fa4a6dbaef2b4e4c8a218cd617cd6d Mon Sep 17 00:00:00 2001
From: Clement Escoffier <clement.escoffier@gmail.com>
Date: Wed, 26 Jun 2019 09:10:37 +0200
Subject: [PATCH 4/7] Define the OSGi Version on the SPI package to be used as
 baseline

Signed-off-by: Clement Escoffier <clement.escoffier@gmail.com>
---
 .../microprofile/reactive/messaging/spi/package-info.java        | 1 +
 1 file changed, 1 insertion(+)

diff --git a/api/src/main/java/org/eclipse/microprofile/reactive/messaging/spi/package-info.java b/api/src/main/java/org/eclipse/microprofile/reactive/messaging/spi/package-info.java
index bebfd4b2..ad8b3768 100644
--- a/api/src/main/java/org/eclipse/microprofile/reactive/messaging/spi/package-info.java
+++ b/api/src/main/java/org/eclipse/microprofile/reactive/messaging/spi/package-info.java
@@ -39,4 +39,5 @@
  * {@link org.eclipse.microprofile.reactive.messaging.spi.Connector} qualifier. Connectors receive the channel
  * configuration matching their {@link Connector} name.
  */
+@org.osgi.annotation.versioning.Version("1.0")
 package org.eclipse.microprofile.reactive.messaging.spi;

From 5b3a6133122e5e9ce359c149f811ce582ad0c05f Mon Sep 17 00:00:00 2001
From: Clement Escoffier <clement.escoffier@gmail.com>
Date: Wed, 26 Jun 2019 09:55:05 +0200
Subject: [PATCH 5/7] Rephrase post-acknowledgement

Signed-off-by: Clement Escoffier <clement.escoffier@gmail.com>
---
 .../eclipse/microprofile/reactive/messaging/Acknowledgment.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/api/src/main/java/org/eclipse/microprofile/reactive/messaging/Acknowledgment.java b/api/src/main/java/org/eclipse/microprofile/reactive/messaging/Acknowledgment.java
index c972fe5d..b680c0f4 100644
--- a/api/src/main/java/org/eclipse/microprofile/reactive/messaging/Acknowledgment.java
+++ b/api/src/main/java/org/eclipse/microprofile/reactive/messaging/Acknowledgment.java
@@ -57,7 +57,7 @@ enum Strategy {
     PRE_PROCESSING,
 
     /**
-     * Acknowledgment performed automatically after the message being processed.
+     * Acknowledgment performed automatically once the message has been processed.
      * When {@code POST_PROCESSING} is used, the incoming message is acknowledged when the produced message is
      * acknowledged.
      *

From afb4c5e4b500b9bd9c479bdb94547c2849e6eeec Mon Sep 17 00:00:00 2001
From: Clement Escoffier <clement.escoffier@gmail.com>
Date: Wed, 26 Jun 2019 10:05:49 +0200
Subject: [PATCH 6/7] Fix spelling issues in the spec document

Signed-off-by: Clement Escoffier <clement.escoffier@gmail.com>
---
 spec/src/main/asciidoc/architecture.asciidoc | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/spec/src/main/asciidoc/architecture.asciidoc b/spec/src/main/asciidoc/architecture.asciidoc
index 11654ca5..1097ba94 100644
--- a/spec/src/main/asciidoc/architecture.asciidoc
+++ b/spec/src/main/asciidoc/architecture.asciidoc
@@ -57,8 +57,8 @@ These channels are managed by _connectors_.
 ==== Message
 
 At the core of the Reactive Messaging specification is the concept of _message_. 
-A _message_  is an enveloppe wrapping a _payload_. 
-A message is sent to a specific channel and, when received and processed successfuly, _acknowledged_.
+A _message_  is an envelope wrapping a _payload_.
+A message is sent to a specific channel and, when received and processed successfully, _acknowledged_.
 
 Reactive Messaging application components are addressable recipients which await the arrival of messages on a channel and react to them, otherwise lying dormant. 
 
@@ -73,7 +73,7 @@ Note that the `ack` method is asynchronous as acknowledgement is generally an as
 _Plain_ messages are created using:
 
 * `org.eclipse.microprofile.reactive.messaging.Message#of(T)` - wraps the given payload, no acknowledgement
-* `org.eclipse.microprofile.reactive.messaging.Message#of(T, java.util.function.Supplier<java.util.concurrent.CompletionStage<java.lang.Void>>)` - wraps the given payload and provides the acknowlegment logic
+* `org.eclipse.microprofile.reactive.messaging.Message#of(T, java.util.function.Supplier<java.util.concurrent.CompletionStage<java.lang.Void>>)` - wraps the given payload and provides the acknowledgment logic
 
 ==== Message consumption with @Incoming
 
@@ -163,7 +163,7 @@ This mapping is configured in the application configuration.
 Note that an implementation may provide various ways to configure the mapping, but support for MicroProfile Config as a configuration source is mandatory.
 
 Connector implementations are associated with a name corresponding to a messaging transport, such as Apache Kafka, Amazon Kinesis, RabbitMQ or Apache ActiveMQ.
-For instance, an hypothetic Kafka connector could be associated with the following name: `acme.kafka`.
+For instance, an hypothetical Kafka connector could be associated with the following name: `acme.kafka`.
 This name is indicated using a qualifier on the connector implementation.
 
 The user can associate a channel with this connector using the associated name:

From c93be448741659a1d0829d8c8113b390cffe143b Mon Sep 17 00:00:00 2001
From: Clement Escoffier <clement.escoffier@gmail.com>
Date: Wed, 26 Jun 2019 11:40:28 +0200
Subject: [PATCH 7/7] Apply Gordon's review.

Signed-off-by: Clement Escoffier <clement.escoffier@gmail.com>
---
 .../microprofile/reactive/messaging/spi/package-info.java       | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/api/src/main/java/org/eclipse/microprofile/reactive/messaging/spi/package-info.java b/api/src/main/java/org/eclipse/microprofile/reactive/messaging/spi/package-info.java
index ad8b3768..53b1686a 100644
--- a/api/src/main/java/org/eclipse/microprofile/reactive/messaging/spi/package-info.java
+++ b/api/src/main/java/org/eclipse/microprofile/reactive/messaging/spi/package-info.java
@@ -20,7 +20,7 @@
 /**
  * The MicroProfile Reactive Messaging API Connector SPI
  * <p>
- * This package provides the SPI to implement {@code connector}. A {@code connector} can be seen as a Reactive Messaging
+ * This package provides the SPI to implement {@code connectors}. A {@code connector} can be seen as a Reactive Messaging
  * plug-in to support a specific messaging technology. For example, you can have a Kafka connector to deal with Kafka,
  * an AMQP connector to interact with AMQP brokers and routers and so on. Connector implementation should be
  * agnostic to the Reactive Messaging implementation.