Fix typos (#406)

* Fix typos

Signed-off-by: Piotrek Żygieło <piotr@zygielo.pl>

* Switch to OpenJDK to fix build on xenial

.travis.yml

@@ -3,7 +3,7 @@ sudo: false
 install: mvn -Pstaging install -DskipTests=true -Dmaven.javadoc.skip=true -B -V
 script: mvn -Pstaging test -B
 jdk:
-  - oraclejdk8
+  - openjdk8
 
 cache:
   directories:
@@ -17,4 +17,4 @@ notifications:
       - "chat.freenode.net#cdi-dev"
     on_success: change  # options: [always|never|change] default: always
     on_failure: always  # options: [always|never|change] default: always
-    on_start: never     # options: [always|never|change] default: always
+    on_start: never     # options: [always|never|change] default: always

spec/src/main/asciidoc/architecture.asciidoc

@@ -15,20 +15,20 @@ This specification defines a powerful set of complementary services that help to
 
 
 The services defined by this specification allow objects to be bound to lifecycle contexts, to be injected, to be associated with interceptors and decorators, and to interact in a loosely coupled fashion by firing and observing events.
-Various kinds of objects are injectable, including Jakarta Eneterprise Bean 3 session beans, managed beans and Jakarta EE resources.
+Various kinds of objects are injectable, including Jakarta Enterprise Bean 3 session beans, managed beans and Jakarta EE resources.
 We refer to these objects in general terms as _beans_ and to instances of beans that belong to contexts as _contextual instances_.
 Contextual instances may be injected into other objects by the dependency injection service.
 
 To take advantage of these facilities, the developer provides additional bean-level metadata in the form of Java annotations and application-level metadata in the form of an XML descriptor.
 
 The use of these services significantly simplifies the task of creating Jakarta EE applications by integrating the Jakarta EE web tier with Jakarta EE enterprise services.
-In particular, Jakarta Eneterprise Bean components may be used as Jakarta Server Faces managed beans, thus integrating the programming models of Jakarta Eneterprise Bean and Jakarta Server Faces.
+In particular, Jakarta Enterprise Bean components may be used as Jakarta Server Faces managed beans, thus integrating the programming models of Jakarta Enterprise Bean and Jakarta Server Faces.
 
 It's even possible to integrate with third-party frameworks.
 A portable extension may provide objects to be injected or obtain contextual instances using the dependency injection service. The framework may even raise and observe events using the event notification service.
 
 An application that takes advantage of these services may be designed to execute in either the Jakarta EE environment or the Java SE environment.
-If the application uses Jakarta EE services such as transaction management and persistence in the Java SE environment, the services are usually restricted to, at most, the subset defined for embedded usage by the Jakarta Eneterprise Bean specification.
+If the application uses Jakarta EE services such as transaction management and persistence in the Java SE environment, the services are usually restricted to, at most, the subset defined for embedded usage by the Jakarta Enterprise Bean specification.
 
 === Contracts
 
@@ -39,7 +39,7 @@ This specification defines the responsibilities of:
 
 
 This runtime environment is called the _container_.
-For example, the container might be a Jakarta EE container or an embeddable Jakarta Eneterprise Bean container.
+For example, the container might be a Jakarta EE container or an embeddable Jakarta Enterprise Bean container.
 
 <<concepts>>, <<implementation>>, <<inheritance>>, <<interceptors>>, <<decorator_bean>> and <<observer_methods>> define the programming model for Jakarta EE components that take advantage of the services defined by this specification, the responsibilities of the component developer, and the annotations used by the component developer to specify metadata.
 
@@ -64,15 +64,15 @@ The Jakarta EE platform specification defines a facility for injecting _resource
 Resources are identified by string-based names.
 This specification bolsters that functionality, adding the ability to inject an open-ended set of object types, including, but not limited to, component environment resources, based upon typesafe qualifiers.
 
-==== Relationship to Jakarta Eneterprise Bean
+==== Relationship to Jakarta Enterprise Bean
 
-Jakarta Eneterprise Bean defines a programming model for application components that access transactional resources in a multi-user environment.
-Jakarta Eneterprise Bean allows concerns such as role-based security, transaction demarcation, concurrency and scalability to be specified declaratively using annotations and XML deployment descriptors and enforced by the Jakarta Eneterprise Bean container at runtime.
+Jakarta Enterprise Bean defines a programming model for application components that access transactional resources in a multi-user environment.
+Jakarta Enterprise Bean allows concerns such as role-based security, transaction demarcation, concurrency and scalability to be specified declaratively using annotations and XML deployment descriptors and enforced by the Jakarta Enterprise Bean container at runtime.
 
-Jakarta Eneterprise Bean components may be stateful, but are not by nature contextual.
+Jakarta Enterprise Bean components may be stateful, but are not by nature contextual.
 References to stateful component instances must be explicitly passed between clients and stateful instances must be explicitly destroyed by the application.
 
-This specification enhances the Jakarta Eneterprise Bean component model with contextual lifecycle management.
+This specification enhances the Jakarta Enterprise Bean component model with contextual lifecycle management.
 
 Any session bean instance obtained via the dependency injection service is a contextual instance. It is bound to a lifecycle context and is available to other objects that execute in that context.
 The container automatically creates the instance when it is needed by a client.
@@ -277,9 +277,9 @@ When the login form is submitted, Jakarta Server Faces assigns the entered usern
 Next, Jakarta Server Faces calls the `login()` method of an instance of `Login` that is automatically instantiated by the container.
 This instance continues to exist for and be available to other requests in the same HTTP session, and provides the `User` object representing the current user to any other bean that requires it (for example, `DocumentEditor`). If the producer method is called before the `login()` method initializes the user object, it throws a `NotLoggedInException`.
 
-==== Jakarta Eneterprise Bean example
+==== Jakarta Enterprise Bean example
 
-Alternatively, we could write our `Login` bean to take advantage of the functionality defined by Jakarta Eneterprise Bean:
+Alternatively, we could write our `Login` bean to take advantage of the functionality defined by Jakarta Enterprise Bean:
 
 [source, java]
 ----
@@ -320,8 +320,8 @@ public class Login {
 }
 ----
 
-The Jakarta Eneterprise Bean `@Stateful` annotation specifies that this bean is an Jakarta Eneterprise Bean stateful session bean.
-The Jakarta Eneterprise Bean `@TransactionAttribute` and `@RolesAllowed` annotations declare the Jakarta Eneterprise Bean transaction demarcation and security attributes of the annotated methods.
+The Jakarta Enterprise Bean `@Stateful` annotation specifies that this bean is an Jakarta Enterprise Bean stateful session bean.
+The Jakarta Enterprise Bean `@TransactionAttribute` and `@RolesAllowed` annotations declare the Jakarta Enterprise Bean transaction demarcation and security attributes of the annotated methods.
 
 ==== Jakarta EE component environment example
 

spec/src/main/asciidoc/core/packagingdeployment.asciidoc

@@ -42,7 +42,7 @@ When determining which archives are bean archives, the container must consider:
 * Library jars
 * Directories in the JVM classpath
 
-Non Jakarta EE containers may or may not provide support for war, Jakarta Eneterprise Bean jar or rar bean archives.
+Non Jakarta EE containers may or may not provide support for war, Jakarta Enterprise Bean jar or rar bean archives.
 
 The `beans.xml` file must be named:
 

spec/src/main/asciidoc/dictionary.txt

@@ -15,8 +15,8 @@ decorators
 DoD
 EE
 EG
-Jakarta Eneterprise Bean
-Jakarta Eneterprise Beans
+Jakarta Enterprise Bean
+Jakarta Enterprise Beans
 enablement
 enum
 enums

spec/src/main/asciidoc/javaee/decorators_ee.asciidoc

@@ -2,11 +2,11 @@
 
 == Decorators in Jakarta EE
 
-When running in Jakarta EE, the container must extend the rules defined for managed beans in <<decorators>> to Jakarta Eneterprise Bean session beans.
+When running in Jakarta EE, the container must extend the rules defined for managed beans in <<decorators>> to Jakarta Enterprise Bean session beans.
 
 [[decorator_bean_ee]]
 
 === Decorator beans in Jakarta EE
 
-Decorators of an Jakarta Eneterprise Bean session bean must comply with the bean provider programming restrictions defined by the Jakarta Eneterprise Bean specification.
-Decorators of an Jakarta Eneterprise Bean stateful session bean must comply with the rules for instance passivation and conversational state defined by the Jakarta Eneterprise Bean specification.
+Decorators of an Jakarta Enterprise Bean session bean must comply with the bean provider programming restrictions defined by the Jakarta Enterprise Bean specification.
+Decorators of an Jakarta Enterprise Bean stateful session bean must comply with the rules for instance passivation and conversational state defined by the Jakarta Enterprise Bean specification.

spec/src/main/asciidoc/javaee/definition_ee.asciidoc

@@ -20,7 +20,7 @@ When running in Jakarta EE, the container must extend the capabilities defined i
 
 === Bean types for Jakarta EE component
 
-As managed beans, Jakarta Eneterprise Bean session beans may have multiple bean types depending on their client-visible types.
+As managed beans, Jakarta Enterprise Bean session beans may have multiple bean types depending on their client-visible types.
 For instance, this session bean has only the local interfaces `BookShop` and `Auditable`, along with `Object`, as bean types, since the bean class is not a client-visible type.
 
 [source, java]
@@ -39,10 +39,10 @@ The rules for determining the (unrestricted) set of bean types for Jakarta EE co
 
 === Scopes
 
-Jakarta EE components such as servlets, Jakarta Eneterprise Beans and JavaBeans do not have a well-defined _scope_.
+Jakarta EE components such as servlets, Jakarta Enterprise Beans and JavaBeans do not have a well-defined _scope_.
 These components are either:
 
-* _singletons_, such as Jakarta Eneterprise Bean singleton session beans, whose state is shared between all clients,
+* _singletons_, such as Jakarta Enterprise Bean singleton session beans, whose state is shared between all clients,
 * _stateless objects_, such as servlets and stateless session beans, which do not contain client-visible state, or
 * objects that must be explicitly created and destroyed by their client, such as JavaBeans and stateful session beans, whose state is shared by explicit reference passing between clients.
 
@@ -60,19 +60,19 @@ When running in Jakarta EE, the implementations of the @RequestScoped, @Applicat
 
 When running in Jakarta EE, If the _bean discovery mode_ is `annotated`, the container must extend the rules defined in <<default_bean_discovery>> with:
 
-* bean classes of Jakarta Eneterprise Bean sessions beans, are discovered, and
-* producer methods that are on an Jakarta Eneterprise Bean session bean are discovered, and
-* producer fields that are on an Jakarta Eneterprise Bean session bean are discovered, and
-* disposer methods that are on an Jakarta Eneterprise Bean session bean are discovered, and
-* observer methods that are on an Jakarta Eneterprise Bean session bean are discovered.
+* bean classes of Jakarta Enterprise Bean sessions beans, are discovered, and
+* producer methods that are on an Jakarta Enterprise Bean session bean are discovered, and
+* producer fields that are on an Jakarta Enterprise Bean session bean are discovered, and
+* disposer methods that are on an Jakarta Enterprise Bean session bean are discovered, and
+* observer methods that are on an Jakarta Enterprise Bean session bean are discovered.
 
 
 [[names_ee]]
 === Bean names in Jakarta EE
 
 A bean with a name may be referred to by its name in Unified EL expressions.
 
-There is no relationship between the bean name of an Jakarta Eneterprise Bean session bean and the Jakarta Eneterprise Bean name of the bean.
+There is no relationship between the bean name of an Jakarta Enterprise Bean session bean and the Jakarta Enterprise Bean name of the bean.
 
 Bean names allow the direct use of beans in JSP or Jakarta Server Faces pages, as defined in <<el>>.
 For example, a bean with the name `products` could be used like this:
@@ -84,7 +84,7 @@ For example, a bean with the name `products` could be used like this:
 
 [[default_name_ee]]
 
-==== Default bean names for Jakarta Eneterprise Bean session beans
+==== Default bean names for Jakarta Enterprise Bean session beans
 
-In the circumstances listed in <<default_name>>, the rule for determining default name for an Jakarta Eneterprise Bean session bean are defined in <<session_bean_name>>.
+In the circumstances listed in <<default_name>>, the rule for determining default name for an Jakarta Enterprise Bean session bean are defined in <<session_bean_name>>.
 

spec/src/main/asciidoc/javaee/events_ee.asciidoc

@@ -4,21 +4,21 @@
 
 [[observer_methods_ee]]
 
-=== Observer methods in Jakarta Eneterprise Bean session beans
+=== Observer methods in Jakarta Enterprise Bean session beans
 
-An observer method may also be a non-abstract method of an Jakarta Eneterprise Bean session bean class.
-It must be either a business method exposed by a local business interface of the Jakarta Eneterprise Bean or a static method of the bean class.
+An observer method may also be a non-abstract method of an Jakarta Enterprise Bean session bean class.
+It must be either a business method exposed by a local business interface of the Jakarta Enterprise Bean or a static method of the bean class.
 
 [[observes_ee]]
 
-==== Declaring an observer method in an Jakarta Eneterprise Bean
+==== Declaring an observer method in an Jakarta Enterprise Bean
 
-If a non-static method of a session bean class has a parameter annotated `@Observes` or `@ObservesAsync`, and the method is not a business method exposed by a local business interface of the Jakarta Eneterprise Bean, the container automatically detects the problem and treats it as a definition error.
+If a non-static method of a session bean class has a parameter annotated `@Observes` or `@ObservesAsync`, and the method is not a business method exposed by a local business interface of the Jakarta Enterprise Bean, the container automatically detects the problem and treats it as a definition error.
 
 [[observer_method_invocation_context_ee]]
 
 ==== Observer method invocation context in Jakarta EE
 
 When Running in Jakarta EE, the container must extend the rules defined in <<observer_method_invocation_context>> and must also ensure that all kinds of observers are called in the same client security context as the invocation of `Event.fire()` or `Event.fireAsync()` or `BeanManager.fireEvent()`.
 
-The transaction and security contexts for a business method exposed by a local business interface of an Jakarta Eneterprise Bean session bean also depend upon the transaction attribute and `@RunAs` descriptor, if any.
+The transaction and security contexts for a business method exposed by a local business interface of an Jakarta Enterprise Bean session bean also depend upon the transaction attribute and `@RunAs` descriptor, if any.