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)                 |
@@ -380,7 +380,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]]
@@ -361,7 +361,7 @@ public final class BookmarkCapture
 }
 ----
 
-For seeding the transaction system, a customized transactionmanager like the the following is required:
+For seeding the transaction system, a customized transaction manager like the following is required:
 
 [source,java,indent=0,tabsize=4]
 .BookmarkSeedingConfig.java
@@ -402,7 +402,7 @@ public class BookmarkSeedingConfig {
 <.> Pass it on to the customized transaction manager
 
 WARNING: There is *no* need to do any of these things above, unless your application has the need to access or provide
-         this data. If in doubt, don't do neither.
+         this data. If in doubt, don't do either.
 
 [[faq.annotations.specific]]
 == Do I need to use Neo4j specific annotations?
@@ -557,7 +557,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]
 ----
@@ -578,7 +578,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:
 
 
@@ -690,7 +690,7 @@ What are the alternatives?
 * <<projections.sdn.general-remarks,Projections>> might be already enough to shape your *view* on the graph: They can be used to define
   the depth of fetching properties and related entities in an explicit way: By modelling them.
 * If your goal is to make only the conditions of your queries *dynamic*, then have a look at the <<core.extensions.querydsl, `QuerydslPredicateExecutor`>>
-  but especially our own variant of it, the `CypherdslConditionExecutor`. Both <<sdn-mixins,mixins>> allow to add conditions to
+  but especially our own variant of it, the `CypherdslConditionExecutor`. Both <<sdn-mixins,mixins>> allow adding conditions to
   the full queries we create for you. Thus, you will have the domain fully populated together with custom conditions.
   Of course, your conditions must work with what we generate. Find the names of the root node, the related nodes and more
   <<custom-queries,here>>.
@@ -710,7 +710,7 @@ Why speaking about custom repository fragments now?
 * You might have more complex situation in which more than one dynamic query is required, but the queries still belong
   conceptually in a repository and not in the service layer
 * Your custom queries return 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
+  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:
@@ -725,9 +725,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`:
 
@@ -758,21 +758,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:
@@ -798,7 +798,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.
@@ -816,7 +816,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.
@@ -855,11 +855,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 enable this base repository for all declared repesotiries 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.
@@ -148,8 +148,8 @@ module your.module {
 	exports your.domain; // <.>
 }
 ----
-<.> Spring Data Neo4j uses Spring Data Commons and it's reflective capabilities, so
-    you would need to open up your domain packages to `spring.core`  at least.
+<.> Spring Data Neo4j uses Spring Data Commons and its reflective capabilities, so
+    you would need to open up your domain packages to `spring.core` at least.
 <.> We assume here that `your.domain` contains also repositories: Those must be exported to be accessible by
     `spring.beans`, `spring.context` and `spring.data.commons`. If you don't want to export them to the world,
     you can restrict them to those modules.

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