GH-2402 - Fix spelling and grammar errors.

Author: rlippolis

src/main/asciidoc/appendix/custom-queries.adoc

@@ -38,7 +38,7 @@ If this would get mapped into a list, it will contain duplicates for the `Movie`
 
 To get the right object(s) back, it is required to _collect_ the relationships and related nodes in the query: `MATCH (m:Movie{title: 'The Matrix'})<-[r:ACTED_IN]-(p:Person) return m,collect(r),collect(p)`
 
-.Single record (shortended)
+.Single record (shortened)
 ----
 +------------------------------------------------------------------------+
 | m        | collect(r)                     | collect(p)                 |
@@ -205,7 +205,7 @@ The following example basically defines the same query as above, but uses a `WHE
 include::../../../../src/test/java/org/springframework/data/neo4j/documentation/repositories/domain_events/ARepository.java[tags=spel]
 ----
 
-The SpEL blocked starts with `:#{` and than refers to the given `String` parameters by name (`#pt1`).
+The SpEL blocked starts with `:#{` and then refers to the given `String` parameters by name (`#pt1`).
 Don't confuse this with the above Cypher syntax!
 The SpEL expression concatenates both parameters into one single value that is eventually passed on to the <<neo4j-client>>.
 The SpEL block ends with `}`.

src/main/asciidoc/appendix/migrating.adoc

@@ -13,21 +13,21 @@ It depends to large extend on the Spring Data and therefore, on the Spring Frame
 Depending on how the application has been structured, that is, how much the any of the framework part leaked into your business code, the more you have to adapt your application.
 It gets worse when you have more than one Spring Data module in your application, if you accessed a relational database in the same service layer as your graph database.
 Updating two object mapping frameworks is not fun.
-Relying on a embedded database configured through Spring Data itself::
+Relying on an embedded database configured through Spring Data itself::
 The embedded database in a SDN+OGM project is configured by Neo4j-OGM.
 Say you want to upgrade from Neo4j 3.0 to 3.5, you can't without upgrading your whole application.
 Why is that?
 As you chose to embed a database into your application, you tied yourself into the modules that configure this embedded database.
 To have another, embedded database version, you have to upgrade the module that configured it, because the old one does not support the new database.
 As there is always a Spring Data version corresponding to Neo4j-OGM, you would have to upgrade that as well.
-Spring Data however depends on Spring Framework and than the arguments from the first bullet apply.
+Spring Data however depends on Spring Framework and then the arguments from the first bullet apply.
 Being unsure about which building blocks to include::
 It's not easy to get the terms right.
 We wrote the building blocks of an SDN+OGM setting https://michael-simons.github.io/neo4j-sdn-ogm-tips/what_are_the_building_blocks_of_sdn_and_ogm.html[here].
 It may be so that all of them have been added by coincidence and you're dealing with a lot of conflicting dependencies.
 
 TIP: Backed by those observations, we recommend to make sure you're using only the Bolt or http transport in your current application before switching from SDN+OGM to SDN.
-Thus, your application and the access layer of your application is to large extend independent from the databases version.
+Thus, your application and the access layer of your application is to a large extent independent of the database's version.
 From that state, consider moving from SDN+OGM to SDN.
 
 [[migrating.preparation]]
@@ -136,7 +136,7 @@ Both `@EnableBookmarkManagement` and `@UseBookmark` as well as the `org.springfr
 interface and its only implementation `org.springframework.data.neo4j.bookmark.CaffeineBookmarkManager` are gone and are not needed anymore.
 
 SDN uses Bookmarks for all transactions, without configuration.
-You can remove the bean declaration of `CaffeineBookmarkManager` as well as the the dependency to `com.github.ben-manes.caffeine:caffeine`.
+You can remove the bean declaration of `CaffeineBookmarkManager` as well as the dependency to `com.github.ben-manes.caffeine:caffeine`.
 
 [[migrating.autoindex]]
 === Automatic creation of constraints and indexes
@@ -158,7 +158,7 @@ they tend to be not so nice in production: How do you handle different versions
 Version A asserting the indexes that have been created by a newer version B?
 
 We think it's better to take control about this upfront and recommend using controlled database migrations, based on a tool like https://www.liquigraph.org[Liquigraph] or https://github.com/michael-simons/neo4j-migrations[Neo4j migrations].
-The later has been seen in use with SDN inside the JHipster project.
+The latter has been seen in use with SDN inside the JHipster project.
 Both projects have in common that they store the current version of the schema within the database and make sure that a schema matches expectations before things are being updated.
 
 Migrating off from previous Neo4j-OGM annotations affects `@Index`, `@CompositeIndex` and `@Required` and an example for those is given here in <<indexed.class>>:

src/main/asciidoc/appendix/neo4j-client.adoc

@@ -5,7 +5,7 @@ Spring Data Neo4j comes with a Neo4j Client, providing a thin layer on top of Ne
 
 While the https://github.com/neo4j/neo4j-java-driver[plain Java driver] is a very versatile tool providing an asynchronous API in addition to the imperative and reactive versions, it doesn't integrate with Spring application level transactions.
 
-SDN uses the driver through the concept of a idiomatic client as directly as possible.
+SDN uses the driver through the concept of an idiomatic client as directly as possible.
 
 The client has the following main goals
 
@@ -36,7 +36,7 @@ Interactions with a Neo4j Client usually ends with a call to
 * `fetch().all()`
 * `run()`
 
-The imperative version will interact at this moment with the database and get the requested results or summary, wrapped in a `Optional<>` or a `Collection`.
+The imperative version will interact at this moment with the database and get the requested results or summary, wrapped in an `Optional<>` or a `Collection`.
 
 The reactive version will in contrast return a publisher of the requested type.
 Interaction with the database and retrieval of the results will not happen until the publisher is subscribed to.
@@ -150,7 +150,7 @@ Both reactive and imperative client offer
 
 The imperative client returns `Optional<T>` and `Collection<T>` respectively, while the reactive client returns `Mono<T>` and `Flux<T>`, the later one being executed only if subscribed to.
 
-If you don't expect any results from your query, than use `run()` after specificity the query.
+If you don't expect any results from your query, then use `run()` after specifying the query.
 
 [[neo4j-client-reactive-get-result-summaries]]
 [source,java]
@@ -172,7 +172,7 @@ Please take a moment to compare both listings and understand the difference when
 
 [[neo4j-client-imperative-get-result-summaries]]
 [source,java]
-.Retrieving result summaries in a imperative way
+.Retrieving result summaries in an imperative way
 ----
 ResultSummary resultSummary = imperativeClient
 	.query("MATCH (m:Movie) where m.title = 'Aeon Flux' DETACH DELETE m")

src/main/asciidoc/faq/faq.adoc

@@ -147,7 +147,7 @@ public class DatabaseSelectionAwareNeo4jHealthIndicator extends AbstractHealthIn
 }
 ----
 
-This uses the available database selection to run the same query that Boot runs to check wether a connection is healthy or not.
+This uses the available database selection to run the same query that Boot runs to check whether a connection is healthy or not.
 Use the following configuration to apply it:
 
 [[faq.multidatabase.health.imperative.config]]
@@ -487,7 +487,7 @@ public interface MyPersonRepository extends Neo4jRepository<Person, Long> {
 == Can I map named paths?
 
 A series of connected nodes and relationships is called a "path" in Neo4j.
-Cypher allows paths to be named using an identifer, as exemplified by:
+Cypher allows paths to be named using an identifier, as exemplified by:
 
 [source,cypher]
 ----
@@ -508,7 +508,7 @@ Which looks like this:
 
 image::bacon-distance.png[]
 
-We find 3 nodes labeled `Person` and 2 nodes labeled `Movie`. Both can be mapped with a custom queury.
+We find 3 nodes labeled `Person` and 2 nodes labeled `Movie`. Both can be mapped with a custom query.
 Assume there's a node entity for both `Person` and `Movie` as well as `Actor` taking care of the relationship:
 
 
@@ -623,8 +623,8 @@ Why speaking about custom repository fragments?
 * You might want to use the Cypher-DSL for building type-safe queries
 * You might have more complex situation in which a dynamic query is required, but the query still belongs
   conceptually in a repository and not in the service layer
-* Your custom query returns a graph shaped result that fits not quite to your domain model
-  and therefore the custom query should be accomponied by a custom mapping as well
+* Your custom queries return a graph shaped result that fits not quite to your domain model
+  and therefore the custom query should be accompanied by a custom mapping as well
 * You have the need for interacting with the driver, i.e. for bulk loads that should not go through object mapping.
 
 Assume the following repository _declaration_ that basically aggregates one base repository plus 3 fragments:
@@ -639,9 +639,9 @@ include::../../../../src/test/java/org/springframework/data/neo4j/documentation/
 The repository contains <<movie-entity, Movies>> as shown in <<example-node-spring-boot-project,the getting started section>>.
 
 The additional interface from which the repository extends (`DomainResults`, `NonDomainResults` and `LowlevelInteractions`)
-are the fragments that addresses all the concerncs above.
+are the fragments that addresses all the concerns above.
 
-=== Using complex, dynamic custom queries and but still returning domain types
+=== Using complex, dynamic custom queries but still returning domain types
 
 The fragment `DomainResults` declares one additional method `findMoviesAlongShortestPath`:
 
@@ -672,21 +672,21 @@ The important takeaway here is:
 
 * The template "knows" your domain objects and maps them accordingly
 * `@Query` is not the only option to define custom queries
-* The can be generated in various ways
+* They can be generated in various ways
 * The `@Transactional` annotation is respected
 
 === Using custom queries and custom mappings
 
 Often times a custom query indicates custom results.
-Should all of those results be mapepd as `@Node`? Of course not! Many times those objects represents read commands
+Should all of those results be mapped as `@Node`? Of course not! Many times those objects represents read commands
 and are not meant to be used as write commands.
 It is also not unlikely that SDN 6 cannot or want not map everything that is possible with Cypher.
 It does however offer several hooks to run your own mapping: On the `Neo4jClient`.
 The benefit of using the SDN 6 `Neo4jClient` over the driver:
 
 * The `Neo4jClient` is integrated with Springs transaction management
 * It has a fluent API for binding parameters
-* It has a fluent API exposing both the records and the Neo4j typesystem so that you can access
+* It has a fluent API exposing both the records and the Neo4j type system so that you can access
   everything in your result to execute the mapping
 
 Declaring the fragment is exactly the same as before:
@@ -712,7 +712,7 @@ include::../../../../src/test/java/org/springframework/data/neo4j/documentation/
 <.> The client takes only in Strings, but the Cypher-DSL can still be used when rendering into a String
 <.> Bind one single value to a named parameter. There's also an overload to bind a whole map of parameters
 <.> This is the type of the result you want
-<.> And finally, the `mappedBy` method, exposing one `Record` for each entry in the result plus the drivers typesystem if needed.
+<.> And finally, the `mappedBy` method, exposing one `Record` for each entry in the result plus the drivers type system if needed.
     This is the API in which you hook in for your custom mappings
 
 The whole query runs in the context of a Spring transaction, in this case, a read-only one.
@@ -730,7 +730,7 @@ include::../../../../src/test/java/org/springframework/data/neo4j/documentation/
 ----
 <.> Work with the driver directly. As with all the examples: There is no need for `@Autowired` magic. All the fragments
     are actually testable on their own.
-<.> The usecase is made up. Here we use a driver managed transaction deleting the whole graph and return the number of
+<.> The use case is made up. Here we use a driver managed transaction deleting the whole graph and return the number of
     deleted nodes and relationships
 
 This interaction does of course not run in a Spring transaction, as the driver does not know about Spring.
@@ -769,11 +769,11 @@ include::../../../../src/test/java/org/springframework/data/neo4j/integration/im
 <.> This signature is required by the base class. Take the `Neo4jOperations` (the actual specification of the `Neo4jTemplate`)
     and the entity information and store them on an attribute if needed.
 
-In this example we forbide the use of the `findAll` method.
+In this example we forbid the use of the `findAll` method.
 You could add methods taking in a fetch depth and run custom queries based on that depth.
 One way to do this is shown in <<domain-results>>.
 
-To use this base repository for all declared repositories enable Neo4j repositories with: `@EnableNeo4jRepositories(repositoryBaseClass = MyRepositoryImpl.class)`.
+To enable this base repository for all declared repositories enable Neo4j repositories with: `@EnableNeo4jRepositories(repositoryBaseClass = MyRepositoryImpl.class)`.
 
 [[faq.entities.auditing]]
 == How do I audit entities?

src/main/asciidoc/getting-started/getting-started.adoc

@@ -29,15 +29,15 @@ If you don't have a running database but Docker installed, please run:
 docker run --publish=7474:7474 --publish=7687:7687 -e 'NEO4J_AUTH=neo4j/secret' neo4j:{neo4j-version}
 ----
 
-You know can access http://localhost:7474/browser/?cmd=play&arg=movies[http://localhost:7474].
+You can now access http://localhost:7474/browser/?cmd=play&arg=movies[http://localhost:7474].
 The above command sets the password of the server to `secret`.
 Note the command ready to run in the prompt (`:play movies`).
 Execute it to fill your database with some test data.
 
 [[create-spring-boot-project]]
 == Create a new Spring Boot project
 
-The easiest way to setup a Spring Boot project is https://start.spring.io[start.spring.io]
+The easiest way to set up a Spring Boot project is https://start.spring.io[start.spring.io]
 (which is integrated in the major IDEs as well, in case you don't want to use the website).
 
 Select the "Spring Web Starter" to get all the dependencies needed for creating a Spring based web application.

src/main/asciidoc/introduction-and-preface/building-blocks.adoc

@@ -27,7 +27,7 @@ The template comes in handy in scenarios with a large number of domain classes o
 The highest level of abstraction is a Spring Data repository.
 
 All abstractions of SDN come in both imperative and reactive fashions.
-It is not recommend to mix both programming styles in the same application.
+It is not recommended mixing both programming styles in the same application.
 The reactive infrastructure requires a Neo4j 4.0+ database.
 
 [[sdn-building-blocks]]
@@ -72,7 +72,7 @@ The reactive infrastructure requires a Neo4j 4.0+ database.
 The template mechanism is similar to the templates of others stores.
 Find some more information about it in <<template-support,our FAQ>>.
 The Neo4j Client as such is unique to SDN.
-You will find it's documentation in the <<neo4j-client,appendix>>.
+You will find its documentation in the <<neo4j-client,appendix>>.
 
 [[sdn-packages]]
 == On the package level

src/main/asciidoc/object-mapping/mapping.adoc

@@ -48,8 +48,8 @@ See <<conversions>> for more information on that.
 * `@LastModifiedDate`: Applied at the field level to indicate the last modification date of a node.
 * `@PersistenceConstructor`: Applied at one constructor to mark it as a the preferred constructor when reading entities.
 * `@Persistent`: Applied at the class level to indicate this class is a candidate for mapping to the database.
-* `@Version`: Applied at field level is used for optimistic locking and checked for modification on save operations.
-The initial value is zero which is bumped automatically on every update.
+* `@Version`: Applied at field level it is used for optimistic locking and checked for modification on save operations.
+ The initial value is zero which is bumped automatically on every update.
 
 Have a look at <<auditing>> for all annotations regarding auditing support.
 
@@ -62,11 +62,11 @@ To map an Object to nodes in the graph and vice versa, we need a label to identi
 
 `@Node` has an attribute `labels` that allows you to configure one or more labels to be used when reading and writing instances of the annotated class.
 The `value` attribute is an alias for `labels`.
-If you don't specify a label, than the simple class name will be used as the primary label.
+If you don't specify a label, then the simple class name will be used as the primary label.
 In case you want to provide multiple labels, you could either:
 
 . Supply an array to the `labels` property.
-The first element in the array will considered as the primary label.
+The first element in the array will be considered as the primary label.
 . Supply a value for `primaryLabel` and put the additional labels in `labels`.
 
 The primary label should always be the most concrete label that reflects your domain class.
@@ -285,7 +285,7 @@ NOTE: We haven't modelled the relationship between movies and people in both dir
 Why is that?
 We see the `MovieEntity` as the aggregate root, owning the relationships.
 On the other hand, we want to be able to pull all people from the database without selecting all the movies associated with them.
-Please consider your applications use case before you try to map every relationship in your database in every direction.
+Please consider your application's use case before you try to map every relationship in your database in every direction.
 While you can do this, you may end up rebuilding a graph database inside your object graph and this is not the intention of a mapping framework.
 
 [[mapping.id-handling]]
@@ -294,7 +294,7 @@ While you can do this, you may end up rebuilding a graph database inside your ob
 [[mapping.id-handling.internal-id]]
 === Using the internal Neo4j id
 
-The easiest way to give your domain classes an unique identifier is the combination of `@Id` and `@GeneratedValue`
+The easiest way to give your domain classes a unique identifier is the combination of `@Id` and `@GeneratedValue`
 on a field of type `Long` (preferable the object, not the scalar `long`, as literal `null` is the better indicator whether an instance is new or not):
 
 .Mutable MovieEntity with internal Neo4j id
@@ -367,7 +367,7 @@ You either have to provide a setter for the id attribute or something like a _wi
 
 The `@GeneratedValue` annotation can take a class implementing `org.springframework.data.neo4j.core.schema.IdGenerator` as parameter.
 SDN provides `InternalIdGenerator` (the default) and `UUIDStringGenerator` out of the box.
-The later generates new UUIDs for each entity and returns them as `java.lang.String`.
+The latter generates new UUIDs for each entity and returns them as `java.lang.String`.
 An application entity using that would look like this:
 
 .Mutable MovieEntity with externally generated surrogate key