You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@polygene.apache.org by ni...@apache.org on 2015/07/08 11:43:06 UTC
[03/11] zest-qi4j git commit: Replaced Qi4j with Zest in main documentation. Added trademark (tm) (™) to all Zest words.
Replaced Qi4j with Zest in main documentation.
Added trademark (tm) (™) to all Zest words.
Project: http://git-wip-us.apache.org/repos/asf/zest-qi4j/repo
Commit: http://git-wip-us.apache.org/repos/asf/zest-qi4j/commit/72a43f3c
Tree: http://git-wip-us.apache.org/repos/asf/zest-qi4j/tree/72a43f3c
Diff: http://git-wip-us.apache.org/repos/asf/zest-qi4j/diff/72a43f3c
Branch: refs/heads/develop
Commit: 72a43f3c1a5e260b9b341cfd5fc7c3e55e14add4
Parents: 5bb6dbf
Author: Niclas Hedhman <he...@betfair.com>
Authored: Mon Jul 6 17:54:18 2015 +0300
Committer: Niclas Hedhman <he...@betfair.com>
Committed: Mon Jul 6 17:54:18 2015 +0300
----------------------------------------------------------------------
LICENSE.txt | 10 ++---
NOTICE.txt | 2 +-
README.txt | 28 +++++++-------
core/api/src/docs/api.txt | 2 +-
core/api/src/docs/application.txt | 14 +++----
core/api/src/docs/composition.txt | 10 ++---
core/api/src/docs/concern.txt | 6 +--
core/api/src/docs/configuration.txt | 4 +-
core/api/src/docs/entitycomposite.txt | 2 +-
core/api/src/docs/metrics.txt | 4 +-
core/api/src/docs/mixin.txt | 10 ++---
core/api/src/docs/reference/ref-api.txt | 6 +--
core/api/src/docs/servicecomposite.txt | 10 ++---
core/api/src/docs/structure.txt | 20 +++++-----
core/api/src/docs/type-lookup.txt | 2 +-
core/api/src/docs/unitofwork.txt | 4 +-
core/api/src/docs/valuecomposite.txt | 2 +-
core/bootstrap/src/docs/bootstrap.txt | 16 ++++----
core/functional/src/docs/functional.txt | 10 ++---
core/io/src/docs/io.txt | 14 +++----
core/spi/src/docs/spi.txt | 4 +-
core/spi/src/docs/valueserialization.txt | 2 +-
core/testsupport/src/docs/testsupport.txt | 8 ++--
.../src/docs/es-voldemort.txt | 2 +-
.../indexing-solr/src/docs/index-solr.txt | 2 +-
extensions/indexing-sql/instructions.txt | 8 ++--
libraries/alarm/src/docs/alarm.txt | 4 +-
.../circuitbreaker/src/docs/circuitbreaker.txt | 6 +--
libraries/constraints/src/docs/constraints.txt | 2 +-
libraries/fileconfig/src/docs/fileconfig.txt | 2 +-
libraries/http/src/docs/http.txt | 4 +-
libraries/jmx/src/docs/jmx.txt | 2 +-
libraries/lang-beanshell/README.txt | 2 +-
libraries/lang-jruby/README.txt | 2 +-
libraries/logging/src/docs/logging.txt | 4 +-
libraries/osgi/src/docs/osgi.txt | 8 ++--
libraries/rest-client/src/docs/primer.txt | 6 +--
libraries/scheduler/src/docs/scheduler.txt | 2 +-
libraries/servlet/src/docs/servlet.txt | 6 +--
libraries/shiro-core/src/docs/shiro.txt | 14 +++----
libraries/shiro-web/src/docs/shiro-web.txt | 6 +--
libraries/spring/src/docs/spring.txt | 20 +++++-----
libraries/sql/src/docs/sql.txt | 2 +-
.../tutorials/howto-assembly-application.txt | 16 ++++----
.../src/docs/tutorials/howto-build-system.txt | 30 +++++++--------
.../docs/tutorials/howto-configure-service.txt | 6 +--
.../src/docs/tutorials/howto-create-concern.txt | 4 +-
.../src/docs/tutorials/howto-create-entity.txt | 14 +++----
.../docs/tutorials/howto-create-sideeffect.txt | 4 +-
.../src/docs/tutorials/howto-depend-on-qi4j.txt | 34 ++++++++---------
.../tutorials/howto-leverage-properties.txt | 6 +--
manual/src/docs/tutorials/howto-use-io.txt | 6 +--
.../src/docs/tutorials/howto-writing-docs.txt | 2 +-
manual/src/docs/userguide/core.txt | 26 ++++++-------
manual/src/docs/userguide/extensions.txt | 4 +-
manual/src/docs/userguide/faq.txt | 4 +-
manual/src/docs/userguide/glossary.txt | 40 ++++++++++----------
manual/src/docs/userguide/index.txt | 2 +-
manual/src/docs/userguide/libraries.txt | 2 +-
manual/src/docs/userguide/preface.txt | 16 ++++----
manual/src/docs/userguide/tools.txt | 4 +-
manual/src/docs/website/home.txt | 24 +++++++-----
manual/src/docs/website/related.txt | 4 +-
manual/src/docs/website/samples.txt | 12 +++---
manual/src/docs/website/tutorials.txt | 20 +++++-----
samples/dci-cargo/README.txt | 2 +-
src/bin-dist/NOTICE.txt | 2 +-
src/bin-dist/README.txt | 22 +++++------
tools/envisage/src/docs/envisage.txt | 2 +-
tutorials/composites/src/docs/step1.txt | 4 +-
tutorials/composites/src/docs/step2.txt | 4 +-
tutorials/composites/src/docs/step5.txt | 6 +--
tutorials/composites/src/docs/step7.txt | 8 ++--
tutorials/composites/src/docs/step8.txt | 4 +-
tutorials/composites/src/docs/step9.txt | 4 +-
.../composites/src/docs/tut-composites.txt | 8 ++--
tutorials/introduction/src/docs/background.txt | 14 +++----
tutorials/introduction/src/docs/highlights.txt | 6 +--
tutorials/introduction/src/docs/qi4j-cop.txt | 4 +-
.../introduction/src/docs/state-modeling.txt | 16 ++++----
.../what-is-composite-oriented-programming.txt | 8 ++--
.../introduction/src/docs/whats-an-object.txt | 14 +++----
.../tenminutes/src/docs/ten-minutes.txt | 28 +++++++-------
.../thirtyminutes/src/docs/thirty-minutes.txt | 24 ++++++------
.../twohours/src/docs/two-hours.txt | 8 ++--
.../twominutes/src/docs/two-minutes.txt | 10 ++---
tutorials/services/src/docs/step1.txt | 4 +-
tutorials/services/src/docs/step2.txt | 2 +-
tutorials/services/src/docs/step3.txt | 6 +--
tutorials/services/src/docs/tut-services.txt | 4 +-
90 files changed, 397 insertions(+), 391 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/LICENSE.txt
----------------------------------------------------------------------
diff --git a/LICENSE.txt b/LICENSE.txt
index 09fd2eb..83c4864 100644
--- a/LICENSE.txt
+++ b/LICENSE.txt
@@ -178,9 +178,9 @@
=======================================================================
-Apache Zest Qi4j subcomponents:
+Apache Zest™ subcomponents:
-The Apache Zest Qi4j project contains subcomponents with separate copyright
+The Apache Zest™ project contains subcomponents with separate copyright
notices and license terms. Your use of the source code for the these
subcomponents is subject to the terms and conditions of the following
licenses.
@@ -189,7 +189,7 @@ licenses.
The MIT License
-----------------------------------------------------------------------
-The Apache Zest Qi4j project bundles the following files under the MIT License:
+The Apache Zest™ project bundles the following files under the MIT License:
- jQuery v1.6.4 (https://jquery.com/)
Bundled in the documentation minisite.
@@ -225,14 +225,14 @@ THE SOFTWARE.
The BSD 3-Clauses License
-----------------------------------------------------------------------
-The Apache Zest Qi4j project bundles the following files under the BSD
+The Apache Zest™ project bundles the following files under the BSD
3-Clauses License:
-----------------------------------------------------------------------
The W3C Software License
-----------------------------------------------------------------------
-The Apache Zest Qi4j project bundles the following files under the W3C Software
+The Apache Zest™ project bundles the following files under the W3C Software
License:
- The "xml:" Namespace (http://www.w3.org/XML/1998/namespace)
http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/NOTICE.txt
----------------------------------------------------------------------
diff --git a/NOTICE.txt b/NOTICE.txt
index 0591ae7..fee2893 100644
--- a/NOTICE.txt
+++ b/NOTICE.txt
@@ -1,4 +1,4 @@
-Apache Zest Qi4j SDK
+Apache Zest� (Java Edition) SDK
Copyright 2015 The Apache Software Foundation.
This product includes software developed at
http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/README.txt
----------------------------------------------------------------------
diff --git a/README.txt b/README.txt
index 24711c6..084b39d 100644
--- a/README.txt
+++ b/README.txt
@@ -1,14 +1,14 @@
-Welcome to the world of Apache Zest Qi4j
+Welcome to the world of Apache Zest
- Composite Oriented Programming on the Java platform.
-This Apache Zest Qi4j Source Distribution contains everything you need to
-create Qi4j applications.
+This Apache Zest� Source Distribution contains everything you need to
+create Zest� applications.
-Qi4j started in 2007, and is still in heavy development under the umbrella of
-the Apache Zest project at the Apache Software Foundation. We would like
+Zest� started in 2007, and is still in heavy development under the umbrella of
+the Apache Zest� project at the Apache Software Foundation. We would like
developers around the world to participate in the advancement of this
cool, new and challenging technology. We are especially interested in
people willing to help improve the SDK, samples, tutorials, documentation
@@ -19,20 +19,20 @@ Please see https://zest.apache.org for more information.
Licensing
---------
-All Qi4j code is licensed under an Apache License.
+All Zest� code is licensed under an Apache License.
Third-Party Dependencies may be licensed under other terms. The only
required dependencies are SLF4J (MIT Licence), ASM (BSD Licence) and
Joda-Time (Apache Licence).
-Finally, Qi4j TestSupport depends on JUnit 4.x and its dependencies, which
+Finally, Zest� TestSupport depends on JUnit 4.x and its dependencies, which
is also not included in the SDK itself, as it is present among most Java
developers.
Dependencies not included
-------------------------
-The source distribution contains Qi4j sources only to keep the download
+The source distribution contains Zest� sources only to keep the download
size small. The Gradle build automatically downloads needed dependencies.
If you need to go offline type `./gradlew gooffline` to ensure all needed
dependencies are cached by Gradle.
@@ -41,17 +41,17 @@ If you prefer to use a dependency management system, go to:
https://zest.apache.org/qi4j/latest/howto-depend-on-qi4j.html
-Building Apache Zest Qi4j
--------------------------
-To build Qi4j from sources you only need to have a valid Java JDK >= 7
+Building Apache Zest
+---------------------
+To build Zest� from sources you only need to have a valid Java JDK >= 7
installation.
-This document the Qi4j build system and its usage:
+This document the Zest� build system and its usage:
https://zest.apache.org/qi4j/latest/build-system.html
-Thank you for trying out Apache Zest Qi4j and Composite Oriented Programming.
+Thank you for trying out Apache Zest� and Composite Oriented Programming.
--- Apache Zest Qi4j Team
+-- Apache Zest� Team
http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/core/api/src/docs/api.txt
----------------------------------------------------------------------
diff --git a/core/api/src/docs/api.txt b/core/api/src/docs/api.txt
index 4e0256e..6384db3 100644
--- a/core/api/src/docs/api.txt
+++ b/core/api/src/docs/api.txt
@@ -21,7 +21,7 @@
source=core/api/dev-status.xml
--------------
-The Qi4j Core API is the primary interface for client application code during the main execution phase, i.e. after the
+The Zest� Core API is the primary interface for client application code during the main execution phase, i.e. after the
application has been activated.
include::../../build/docs/buildinfo/artifact.txt[]
http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/core/api/src/docs/application.txt
----------------------------------------------------------------------
diff --git a/core/api/src/docs/application.txt b/core/api/src/docs/application.txt
index e04653f..e38ffcb 100644
--- a/core/api/src/docs/application.txt
+++ b/core/api/src/docs/application.txt
@@ -15,13 +15,13 @@
[[core-api-application,Application]]
= Application =
-There is one and only one Application instance per Qi4j runtime instance. But there is nothing preventing code to
-create additional Qi4j Runtime instances inside the same JVM. However, these runtimes are isolated from each other.
+There is one and only one Application instance per Zest� runtime instance. But there is nothing preventing code to
+create additional Zest� Runtime instances inside the same JVM. However, these runtimes are isolated from each other.
The main purpose of the Application structure artifact is to keep everything in the same box, and allowing us to
navigate the Structure. So, from a client code perspective, the Application is of no use, other than being part of
-bring Qi4j to life. Qi4j doesn't start automatically and can be run in most environments, by requiring that the
-bootstrapping of Qi4j is done by client code. We call this the Bootstrap Phase. The code in the custom bootstrapper
+bring Zest� to life. Zest� doesn't start automatically and can be run in most environments, by requiring that the
+bootstrapping of Zest� is done by client code. We call this the Bootstrap Phase. The code in the custom bootstrapper
will need to access additional Jars from the regular domain code, and we strongly recommend that you make this
separation in your project as well.
@@ -49,7 +49,7 @@ Recap of sequence;
* Create, obtain or lookup Assemblers.
* Establish the application structures.
- * Create a Qi4j Runtime instance.
+ * Create a Zest� Runtime instance.
* Create an ApplicationAssemblyFactory.
* Create an ApplicationFactory.
* Call ApplicationFactory.newApplication() to create an ApplicationContext.
@@ -72,7 +72,7 @@ tag=application1
= Single Module Layering =
Behind the scenes of the SingletonAssembler a little bit more elaborate bootstrap sequence is happening. The code below
-shows what is the actual required sequence to start up Qi4j.
+shows what is the actual required sequence to start up Zest.
[snippet,java]
-----------
@@ -83,7 +83,7 @@ tag=actual
In the above example we are only creating an Application with a single Layer and a single Module in that Layer. This is
derived from the fact that the factory.newApplicationAssembly() method takes a single Assembler argument.
-The Assembler.assemble( ModuleAssembly assembly ) method is called when the Qi4j Runtime needs to populate the
+The Assembler.assemble( ModuleAssembly assembly ) method is called when the Zest� Runtime needs to populate the
ModuleAssembly with its Composites, Objects, Services and other information.
== "Pancake" Layering ==
http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/core/api/src/docs/composition.txt
----------------------------------------------------------------------
diff --git a/core/api/src/docs/composition.txt b/core/api/src/docs/composition.txt
index fecece1..a06c965 100644
--- a/core/api/src/docs/composition.txt
+++ b/core/api/src/docs/composition.txt
@@ -20,14 +20,14 @@ Composition is at the heart of COP, and refers to two different levels of constr
1. the ability to assemble (compose) objects from smaller pieces, called Fragments.
2. the construction of applications by assembling Composites into Modules and Modules into Layers.
-In Qi4j, we use the term Assembly for the second case of composition. See separate chapter.
+In Zest, we use the term Assembly for the second case of composition. See separate chapter.
Composition will allow library authors a new level of flexibility in how functionality is provided to client code. More
on that later.
== Fragments ==
-There are 4 types of Fragments in Qi4j;
+There are 4 types of Fragments in Zest;
* <<core-api-mixin>> - The state carrying part of a Composite.
* <<core-api-constraint>> - Rules for in and out arguments, typically used for validation.
@@ -47,14 +47,14 @@ these, so the right meta type is used for the right purpose.
* Service - Service is injectable to other composites and java objects. They are not persistable, but if
referenced from an Entity or Value, a new reference to the Service will be injected when the Entity/Value is
deserialized. Services are singletons. There are 'hosted' and 'imported' Services. The 'hosted' Service has
- Configuration and its life cycle controlled by the Qi4j runtime, whereas the 'imported' Services are external
+ Configuration and its life cycle controlled by the Zest� runtime, whereas the 'imported' Services are external
references.
* Transient - Short-lived composites that are not persistable. Equals/hashCode/toString are forwarded to the
Mixin Type declaring those methods explicitly.
-In versions of Qi4j prior to 2.0, composite types had to extend one of these 4 meta types, but in 2.0 and later, the
+In versions of Zest� prior to 2.0 (then Qi4j), composite types had to extend one of these 4 meta types, but in 2.0 and later, the
meta type interface is added dynamically during <<core-bootstrap-assembly>>.
-We can therefor get rid of a lot of additional types, and use Qi4j-free interfaces directly;
+We can therefor get rid of a lot of additional types, and use Zest-free interfaces directly;
[snippet,java]
-----------
http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/core/api/src/docs/concern.txt
----------------------------------------------------------------------
diff --git a/core/api/src/docs/concern.txt b/core/api/src/docs/concern.txt
index 6a941fb..0b39a9c 100644
--- a/core/api/src/docs/concern.txt
+++ b/core/api/src/docs/concern.txt
@@ -34,12 +34,12 @@ business domain, and can be used for many important things in the domain model,
ensure that the state in the entire composite is valid), coordinating services, handling events and much more.
Typed Concerns doesn't have to implement all the methods in the Mixin Type. By making the class abstract and only
-implementing the methods of interest, Qi4j will subclass the concern (otherwise not valid for the JVM), but the generated
-methods will never be invoked.
+implementing the methods of interest, Zest� runtime will subclass the concern (otherwise not valid for the JVM), but the
+generated methods will never be invoked.
== Generic Concern ==
In classic AOP, all advice are effectively _generic_. There is no type information in the advice implementation and the
-pointcut can be defined anywhere in the code, and the implementation uses proxy InvocationHandlers. Qi4j supports this
+pointcut can be defined anywhere in the code, and the implementation uses proxy InvocationHandlers. Zest� supports this
construct as well, and we call it *Generic Concern*.
Generic Concerns will be added to all methods that the AppliesToFilter evaluates to true. By default, that is all methods.
http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/core/api/src/docs/configuration.txt
----------------------------------------------------------------------
diff --git a/core/api/src/docs/configuration.txt b/core/api/src/docs/configuration.txt
index 8483b52..d61e0bd 100644
--- a/core/api/src/docs/configuration.txt
+++ b/core/api/src/docs/configuration.txt
@@ -15,14 +15,14 @@
[[core-api-service-configuration,Service Configuration]]
= Service Configuration =
-Configuration in Qi4j is for Qi4j <<core-api-service>> only. The Configuration is stored in a visible Entity
+Configuration in Zest� is for Zest� <<core-api-service>> only. The Configuration is stored in a visible Entity
Store and is therefor runtime modifiable and not static in properties or XML files as in most other dependency
injection frameworks.
The Configuration system itself will handle all the details with interfacing with reading and writing the configuration.
The normal UnitOfWork management is used, but handled internally by the configuration system.
-In Qi4j, Configuration are strongly typed and refactoring-friendly. Configuration is read from the entity store, but if
+In Zest, Configuration are strongly typed and refactoring-friendly. Configuration is read from the entity store, but if
it can not be found, then it will try to bootstrap it from a properties file, with the same name as the
ServiceDescriptor.identifiedBy(), which is set during <<core-bootstrap-assembly>> and defaults to the fully qualified
classname of the <<core-api-service>> type.
http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/core/api/src/docs/entitycomposite.txt
----------------------------------------------------------------------
diff --git a/core/api/src/docs/entitycomposite.txt b/core/api/src/docs/entitycomposite.txt
index e8b06a9..c926545 100644
--- a/core/api/src/docs/entitycomposite.txt
+++ b/core/api/src/docs/entitycomposite.txt
@@ -22,7 +22,7 @@ Hibernate (4+ somewhat incompatible versions) and many other less known. This se
creating objects that survives over long periods of time is a difficult one.
Eric Evans points out in his book that Entities is a very definite and distinct concept that needs to be handled
-explicitly. Composite Oriented Programming in general, and Qi4j in particular, takes this point very seriously and
+explicitly. Composite Oriented Programming in general, and Zest� in particular, takes this point very seriously and
makes Entities a central part of the whole system. And likewise, we are convinced that it is not possible to develop
domain-knowledge-rich applications without a conscious and well-defined strategy on Entities. So, instead of spending
endless hours trying to get Hibernate mapping to do the right thing, we introduce a Composite meta type called
http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/core/api/src/docs/metrics.txt
----------------------------------------------------------------------
diff --git a/core/api/src/docs/metrics.txt b/core/api/src/docs/metrics.txt
index e116d39..6bf8bac 100644
--- a/core/api/src/docs/metrics.txt
+++ b/core/api/src/docs/metrics.txt
@@ -15,7 +15,7 @@
[[core-api-metrics, Metrics API]]
= Metrics API =
-The Qi4j platform defines an advanced Metrics SPI to capture runtime metrics of Qi4j's internals as well be used by
+The Zest� platform defines an advanced Metrics SPI to capture runtime metrics of Zest's internals as well be used by
application code (via this API) to provide production metrics for operations personnel, ensuring healthy state of
the applications.
@@ -25,7 +25,7 @@ There are quite a lot of different Metrics components available, which are insta
factory for each component type, to allow for additional components to be created in the future without breaking
compatibility in the existing implementations.
-The MetricsProvider is a standard Qi4j Service and simply acquired via the @Service annotation on a field or
+The MetricsProvider is a standard Zest� Service and simply acquired via the @Service annotation on a field or
constructor argument.
[snippet,java]
http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/core/api/src/docs/mixin.txt
----------------------------------------------------------------------
diff --git a/core/api/src/docs/mixin.txt b/core/api/src/docs/mixin.txt
index d5cbb89..241b35b 100644
--- a/core/api/src/docs/mixin.txt
+++ b/core/api/src/docs/mixin.txt
@@ -122,16 +122,16 @@ source=core/api/src/test/java/org/qi4j/api/mixin/partial/SpeedMixin.java
tag=partial
-----------
-Above the SpeedMixin only implements the accelerate() method, and Qi4j will only map that method to this mixin. The
+Above the SpeedMixin only implements the accelerate() method, and Zest� will only map that method to this mixin. The
other method of the SpeedLocation interface is not satisfied as the example is written and will generate a runtime
exception.
== Private Mixins ==
-Public mixins expose their methods in the composite interface, and this is not always desirable. Qi4j supports
+Public mixins expose their methods in the composite interface, and this is not always desirable. Zest� supports
_Private Mixins_, which are only visible within the composite itself. That means that other fragments in the composite
can see/use it, but it is not visible to the clients of the composite.
-Private Mixins are handled automatically. When Qi4j detects a @This annotation referring to a type that is not defined
+Private Mixins are handled automatically. When Zest� detects a +@This+ annotation referring to a type that is not defined
in the Composite interface, then that is a Private Mixin. The Mixin implementation class, however, must exist in the
list of Mixins in the @Mixins annotation. But often, the Private Mixin only list internal Property methods in the Mixin
Type, which will be satisfied by the standard PropertyMixin and hence always available.
@@ -172,7 +172,7 @@ Typically, AppliesTo annotation is used to filter the methods that such Generic
and sometimes Generic Mixin implementations are "last resort".
Experience shows that Generic Mixin implementations are rare, and should only be used in extreme cases. They are
-less frequent than Generic Concern or Generic SideEffect implementations, but inside the Qi4j API are a couple of
+less frequent than Generic Concern or Generic SideEffect implementations, but inside the Zest� API are a couple of
Generic Mixin implementations that are always present to make the life of the developer easier, such as PropertyMixin,
AssociationMixin, ManyAssociationMixin, NoopMixin. The first 3 are declared on the Composite and EntityComposite
interfaces and automatically included if needed. They also serve as excellent example of what they can be used for.
@@ -193,6 +193,6 @@ which seems to indicate that Generic Mixin implementations are likely to be used
Typed Mixin implementations are much preferred in general business logic, as they will be first-class citizens of
the IDE as well, for navigation, find usage, refactoring and many other common tasks. This is one of the main
-advantages of the Qi4j way of doing AOP compared to AspectJ et al, where "weaving" is something bolted onto an
+advantages of the Zest� way of doing AOP compared to AspectJ et al, where "weaving" is something bolted onto an
application's classes via regular expressions and known naming conventions, which can change in an instance by a
developer being unaware of which PointCuts applies to his code.
http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/core/api/src/docs/reference/ref-api.txt
----------------------------------------------------------------------
diff --git a/core/api/src/docs/reference/ref-api.txt b/core/api/src/docs/reference/ref-api.txt
index 52458a5..bafff6d 100644
--- a/core/api/src/docs/reference/ref-api.txt
+++ b/core/api/src/docs/reference/ref-api.txt
@@ -14,10 +14,10 @@
//////////////////////
[[ref-core-api, Core API]]
-= Qi4j Core API =
+= Zest� Core API =
-The Qi4j Core API is main API that Qi4j developers interact with. In fact, if you need to use classes/interfaces
-in the Qi4j Core SPI or Qi4j Core Runtime, then please contact the Qi4j Community and explain your use-case.
+The Zest� Core API is main API that Zest� developers interact with. In fact, if you need to use classes/interfaces
+in the Zest� Core SPI or Zest� Core Runtime, then please contact the Zest� Community and explain your use-case.
The Core API is strictly layered, with no _spaghetti_ cross packages. The package list is fairly long, and
we will look at each one in detail further down.
http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/core/api/src/docs/servicecomposite.txt
----------------------------------------------------------------------
diff --git a/core/api/src/docs/servicecomposite.txt b/core/api/src/docs/servicecomposite.txt
index 4a870d1..3f19a6c 100644
--- a/core/api/src/docs/servicecomposite.txt
+++ b/core/api/src/docs/servicecomposite.txt
@@ -16,7 +16,7 @@
[[core-api-service,ServiceComposite]]
= Service Composite =
Any service added, via the ModuleAssembly.addServices(), ModuleAssembly.services() and ModuleAssembly.importServices()
-methods, will have the ServiceComposite meta type added to it. In Qi4j, when we speak of _Services_ we mean instances
+methods, will have the ServiceComposite meta type added to it. In Zest, when we speak of _Services_ we mean instances
of _ServiceComposite_.
Most programmers are familiar with the term "Service", and after the failure of Object Oriented Programming's promise
@@ -24,8 +24,8 @@ to encapsulate all the behavior together with the object's state, programmers le
decoupling and re-use was to make the objects into data containers and deploy services that acted upon those data
containers. Very much what functions did on structs back in the C and Pascal days.
-Qi4j will bring a lot of the behavior back to the Composite itself, but we still need Services for cross-composite
-functionality. The Qi4j Service model is fairly simple, yet powerful and flexible enough to accommodate most
+Zest� will bring a lot of the behavior back to the Composite itself, but we still need Services for cross-composite
+functionality. The Zest� Service model is fairly simple, yet powerful and flexible enough to accommodate most
service-oriented patterns and ability to integrate well with external systems whether they are in-JVM or remote,
such as Spring, OSGi, WS-*, Rest and others.
@@ -37,7 +37,7 @@ The characteristics of a ServiceComposite compared to other Composite meta types
* It has an optional Configuration.
-_Services_ in Qi4j are _singletons_, one instance per definition. That means that there may exist multiple instances
+_Services_ in Zest� are _singletons_, one instance per definition. That means that there may exist multiple instances
of the same service type, but they can not be created on the fly in runtime, but has to be explicitly defined during
<<core-bootstrap-assembly>>.
@@ -46,7 +46,7 @@ will not exist until someone calls a method. If a _Service_ needs to be instanti
need to declare/call the instantiateOnStartup() method on the _ServiceDescriptor_ during the bootstrap.
== Service Configuration ==
-The configuration for a service is well supported in Qi4j. See the <<core-api-service-configuration>> chapter for details.
+The configuration for a service is well supported in Zest. See the <<core-api-service-configuration>> chapter for details.
== Service Activation ==
Services are activated (injected and instantiated) either on application start-up, or upon first use. This is controlled
http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/core/api/src/docs/structure.txt
----------------------------------------------------------------------
diff --git a/core/api/src/docs/structure.txt b/core/api/src/docs/structure.txt
index 1ab7687..9507633 100644
--- a/core/api/src/docs/structure.txt
+++ b/core/api/src/docs/structure.txt
@@ -15,17 +15,17 @@
[[core-api-structure,Structure]]
= Structure =
-Qi4j promotes a conventional view of application structure, that computer science has been using for decades.
+Zest� promotes a conventional view of application structure, that computer science has been using for decades.
The definition is as follows;
- * One Application per Qi4j runtime instance.
+ * One Application per Zest� runtime instance.
* One or more Layers per Application.
* Zero, one or more Modules per Layer.
* Zero, one or more Assemblies per Module.
The principle of this Structure is to assist the programmer to create well modularized applications, that are easily
-extended and maintained. Qi4j will restrict access between Modules, so that code can only reach Composites and Objects
+extended and maintained. Zest� will restrict access between Modules, so that code can only reach Composites and Objects
in Modules (including itself) of the same or lower Layers.
Each Layer has to be declared which lower Layer(s) it uses, and it is not allowed that a lower Layer uses a higher
@@ -33,20 +33,20 @@ Layer, i.e. cyclic references.
[[core-api-application,Application]]
= Application =
-Every Qi4j runtime has _one and only one_ Application in it. It is possible to run multiple Qi4j runtimes in the same
-JVM, and it is even possible to embed a Qi4j runtime within a Qi4j Application, but there can only be one Application
-in a Qi4j runtime.
+Every Zest� runtime has _one and only one_ Application in it. It is possible to run multiple Zest� runtimes in the same
+JVM, and it is even possible to embed a Zest� runtime within a Zest� Application, but there can only be one Application
+in a Zest� runtime.
An Application is then broken into layers and modules are placed within those layers. Composites are placed within
-modules. This forms the Application Structure and is enforced by the Qi4j runtime.
+modules. This forms the Application Structure and is enforced by the Zest� runtime.
[[core-api-layer,Layer]]
= Layer =
-A Qi4j Application must consist of at least one layer. More layers are common, often dividing the application along the
+A Zest� Application must consist of at least one layer. More layers are common, often dividing the application along the
common architectural diagrams used on whiteboards, perhaps with a UI layer at the top, followed by a service or application
layer, then with a domain layer and finally some persistence layer at the bottom.
-Qi4j enforces this layering by requiring the <<core-bootstrap-assembly>> to declare which layer uses which other layer. And
+Zest� enforces this layering by requiring the <<core-bootstrap-assembly>> to declare which layer uses which other layer. And
<<core-api-visibility>> rules define that layers below can not locate composites in layers above. Also, defining that
"Layer1 uses Layer2" and "Layer2 uses Layer3" does NOT imply that Layer1 has <<core-api-visibility>> to Layer3. If that
is wanted, then it must be declared explicitly.
@@ -60,7 +60,7 @@ belongs to a single Layer, but many Modules can exist in the same Layer. Composi
* Composites from Modules in the same Layer, with Visibility set to Visibility.layer
* Composites from Modules in Layers below, with Visibility set to Visibility.application
-Modules contains a lot of the Qi4j infrastructure, which are the enforcers of these wise modularization principles.
+Modules contains a lot of the Zest� infrastructure, which are the enforcers of these wise modularization principles.
It is not possible to modify the Modules, their resolution nor binding in any way after the application starts.
http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/core/api/src/docs/type-lookup.txt
----------------------------------------------------------------------
diff --git a/core/api/src/docs/type-lookup.txt b/core/api/src/docs/type-lookup.txt
index 5e3f31e..100d480 100644
--- a/core/api/src/docs/type-lookup.txt
+++ b/core/api/src/docs/type-lookup.txt
@@ -23,7 +23,7 @@
Composite Types Lookup can occurs when you explicitely lookup for a Composite by Type
(ex. ServiceFinder.findService(..) methods), when you ask for an injection or when you create a new composite instance.
-All theses type lookup start from a Module, are lazy, cached and obey the Qi4j Visibility rules. Type Lookup works
+All theses type lookup start from a Module, are lazy, cached and obey the Zest� Visibility rules. Type Lookup works
equally accross Composite Types with some subtle differences when it comes to Services and Entities.
http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/core/api/src/docs/unitofwork.txt
----------------------------------------------------------------------
diff --git a/core/api/src/docs/unitofwork.txt b/core/api/src/docs/unitofwork.txt
index 04e4f26..582aefe 100644
--- a/core/api/src/docs/unitofwork.txt
+++ b/core/api/src/docs/unitofwork.txt
@@ -19,7 +19,7 @@ A UnitOfWork is a bounded group of operations performed, typically on entities,
to other threads until the UnitOfWork is completed. It is also possible to discard these operations, as if they were
never executed.
-NOTE: UnitOfWork has many similarities with the Transaction concept used with RDBMSes. But since Qi4j introduced several deviations to the common definitions of Transactions, we chose to use a different term.
+NOTE: UnitOfWork has many similarities with the Transaction concept used with RDBMSes. But since Zest� introduced several deviations to the common definitions of Transactions, we chose to use a different term.
There are several key characteristics of UnitOfWork;
@@ -44,5 +44,5 @@ and aborting the UnitOfWork is handled by the transaction boundary, often in the
<<core-api-layer>>)
Since it is very common to have all, or nearly all, methods in the _transaction boundary_ to handle the creation and
-completion, possibly with retry, in the same class, module or even layer, Qi4j provides annotations to easily declare
+completion, possibly with retry, in the same class, module or even layer, Zest� provides annotations to easily declare
UnitOfWork concern: @UnitOfWorkPropagation, @UnitOfWorkDiscardOn and @UnitOfWorkRetry
http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/core/api/src/docs/valuecomposite.txt
----------------------------------------------------------------------
diff --git a/core/api/src/docs/valuecomposite.txt b/core/api/src/docs/valuecomposite.txt
index cc7166e..f080376 100644
--- a/core/api/src/docs/valuecomposite.txt
+++ b/core/api/src/docs/valuecomposite.txt
@@ -21,7 +21,7 @@ immutable and can be compared by value instead of memory reference. Concurrency
the value exists or it doesn't, no need for synchronization. Values are typically very easy to test and very robust to
refactoring.
-Qi4j defines values as a primary meta type through the ValueComposite, as we think the benefits of values are great.
+Zest� defines values as a primary meta type through the ValueComposite, as we think the benefits of values are great.
The ValueComposite is very light-weight compared to the EntityComposite, and its value can still be persisted as part
of an EntityComposite via a Property.
http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/core/bootstrap/src/docs/bootstrap.txt
----------------------------------------------------------------------
diff --git a/core/bootstrap/src/docs/bootstrap.txt b/core/bootstrap/src/docs/bootstrap.txt
index 22165c9..7b500b7 100644
--- a/core/bootstrap/src/docs/bootstrap.txt
+++ b/core/bootstrap/src/docs/bootstrap.txt
@@ -22,9 +22,9 @@
source=core/bootstrap/dev-status.xml
--------------
-Qi4j has a distinct bootstrap phase, also known as the _Assembly_ of an application, where the applications structure
+Zest� has a distinct bootstrap phase, also known as the _Assembly_ of an application, where the applications structure
is defined programmatically. Once all the layers, modules and all the composite types in each module have been defined
-the model is instantiated into an application. This enables the entire _structure_ system in Qi4j, where types "belongs"
+the model is instantiated into an application. This enables the entire _structure_ system in Zest, where types "belongs"
to a module and visibility rules define default behaviors, enforcement of architectural integrity and much more.
The _assembly_ is preceeded by the creation of the _Qi4j Runtime_. The _assembly_ can be declared fully by defining
@@ -43,7 +43,7 @@ You can also;
* Add additional interfaces to composites dynamically.
* Add concerns, mixins, constraints and side effects dynamically.
* Set _meta information_ on defined types.
- * Import external services to be available as Qi4j services.
+ * Import external services to be available as Zest� services.
* Tag services with markers
include::../../build/docs/buildinfo/artifact.txt[]
@@ -168,7 +168,7 @@ tag=UsingAssembler
[[core-bootstrap-assembly-layered,Layered Application Assembler]]
== Layered Application Assembler (RECOMMENDED!) ==
-In 2.1, a new way to instantiate Qi4j applications was introduced. It starts with subclassing the
+In 2.1, a new way to instantiate Zest� applications was introduced. It starts with subclassing the
+LayeredApplicationAssembler+, and implementing the +assembleLayers()+ method.
In the +assembleLayers()+ method, one is epected to either call the +createLayer()+ method in the super class
@@ -206,7 +206,7 @@ For example code, see the tutorial <<howto-assemble-application>>.
== Singleton Assembler ==
-Every Qi4j runtime instance consist of One Application, with one or more Layers and one or more Modules in each Layer.
+Every Zest� runtime instance consist of One Application, with one or more Layers and one or more Modules in each Layer.
So the minimal application is still one layer with one module. This is not recommended other than for testing purposes
and really trivial applications.
@@ -218,7 +218,7 @@ source=core/bootstrap/src/test/java/org/qi4j/bootstrap/DocumentationSupport.java
tag=singleton
--------------
-Once the SingletonAssembler constructor returns, the Qi4j application is up and running.
+Once the SingletonAssembler constructor returns, the Zest� application is up and running.
The SingletonAssembler also makes common system resources available from the bootstrap code, such as
Module, UnitOfWorkFactory and others. This is possible since there is only one Module.
@@ -274,10 +274,10 @@ tag=pancake
== Full Assembly ==
Full Assembly means that you have the opportunity to create any layer/module hierarchy that are within the rules of the
-Qi4j runtime. It requires more support in your code to be useful, and the example below is by no means a recommended way
+Zest� runtime. It requires more support in your code to be useful, and the example below is by no means a recommended way
to organize large application assemblies.
-In principle, you first start the Qi4j runtime, call newApplication with an ApplicationAssembler instance and call
+In principle, you first start the Zest� runtime, call newApplication with an ApplicationAssembler instance and call
activate() on the returned application. The ApplicationAssembler instance will be called with an
ApplicationAssemblyFactory, which is used to create an ApplicationAssembly describing the application structure.
http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/core/functional/src/docs/functional.txt
----------------------------------------------------------------------
diff --git a/core/functional/src/docs/functional.txt b/core/functional/src/docs/functional.txt
index 30a2a2b..1b0c3f4 100644
--- a/core/functional/src/docs/functional.txt
+++ b/core/functional/src/docs/functional.txt
@@ -21,9 +21,9 @@
source=core/functional/dev-status.xml
--------------
-The Qi4j Core Functional API is a generic package to work with Iterables in a "functional programming language" style.
+The Zest� Core Functional API is a generic package to work with Iterables in a "functional programming language" style.
-This package is completely independent of everything else in Qi4j and may be used on its own in any kind of environment
+This package is completely independent of everything else in Zest� and may be used on its own in any kind of environment
such as Spring or Java EE applications.
include::../../build/docs/buildinfo/artifact.txt[]
@@ -38,7 +38,7 @@ source=core/functional/src/test/java/org/qi4j/functional/docsupport/FunctionalDo
tag=func1
-----------
-With the Qi4j Core Functional API, you go about it in a different way. The code ends up looking like this;
+With the Zest� Core Functional API, you go about it in a different way. The code ends up looking like this;
[snippet,java]
-----------
@@ -50,11 +50,11 @@ And this is just the tip of the iceberg.
== The Big Picture ==
-The Qi4j Core Functional API are divided a handful of powerful concepts, especially when used together;
+The Zest� Core Functional API are divided a handful of powerful concepts, especially when used together;
* *Iterables* - many methods to deal with Iterable data, so that the loops in your programs can largely be removed.
- * *Functions* - f(x) and f(x,y) are well-know from mathematics and used in functional programming languages. Qi4j is
+ * *Functions* - f(x) and f(x,y) are well-know from mathematics and used in functional programming languages. Zest� is
not capable of introducing lambda calculus due to limitations in Java itself, but we can simulate a lot to allow
people to create more readable code.
http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/core/io/src/docs/io.txt
----------------------------------------------------------------------
diff --git a/core/io/src/docs/io.txt b/core/io/src/docs/io.txt
index 6e02896..a8b85a8 100644
--- a/core/io/src/docs/io.txt
+++ b/core/io/src/docs/io.txt
@@ -21,10 +21,10 @@
source=core/io/dev-status.xml
--------------
-The Qi4j Core I/O API is completely generic and not tied to the Qi4j programming model as a whole. It can be used
-independently of Qi4j, together with the Qi4j Core Functional API, which the Core I/O API depends on.
+The Zest� Core I/O API is completely generic and not tied to the Zest� programming model as a whole. It can be used
+independently of Zest, together with the Zest� Core Functional API, which the Core I/O API depends on.
-The Qi4j Core I/O API tries to address the problem around shuffling data around from various I/O inputs and outputs,
+The Zest� Core I/O API tries to address the problem around shuffling data around from various I/O inputs and outputs,
possibly with transformations and filtering along the way. It was identified that there is a general mix-up of concerns
in the stereotypical I/O handling codebases that people deal with all the time. The reasoning around this, can be found
in the <<howto-use-io>>, and is recommended reading.
@@ -44,7 +44,7 @@ source.copyTo( destination );
It seems natural to do, yet it is not present for us. We need to involve FileInputStream/FileOutputStream, wrap them
in Buffered versions of it, do our own looping, close the streams afterwards and what not. So, the java.io.File does
-not have this simple feature and in the Qi4j Core API, we need to work around this limitation. We also want to
+not have this simple feature and in the Zest� Core API, we need to work around this limitation. We also want to
make the abstraction a little bit more encompassing than "just" files. So how does that look like then?
== First Examples ==
@@ -60,7 +60,7 @@ tag=io1
-----------
Pretty much self-explanatory, wouldn't you say? But what happened to the handling of exceptions and closing of
-resources? It is all handled inside the Qi4j Core I/O API. There is nothing you can forget to do.
+resources? It is all handled inside the Zest� Core I/O API. There is nothing you can forget to do.
Another simple example, where we want to count the number of lines in the text;
@@ -127,7 +127,7 @@ interface. For O/S resources, they are handled purely inside the Input and Outpu
Sender/Receiver are effectively dealing with the data itself.
== org.qi4j.io.Transforms ==
-The 3 component in the Qi4j Core I/O API is the transformations that are possible. Interestingly enough, with the
+The 3 component in the Zest� Core I/O API is the transformations that are possible. Interestingly enough, with the
above separation of concerns, we don't need an InputOutput type that can both receive and send data. Instead, we
simply need to prepare easy to use static factory methods, which are found in the org.qi4j.io.Transforms class. Again,
it is fairly straight forward to create your own Transforms if you need something not provided here.
@@ -176,7 +176,7 @@ tag=progress
It combines the Counter and the Log implementations, so that the count is forwarded to the Log at a given interval, such
as every 1000 items. This may not be what you think a ProgressLog should look like, but it serves as a good example on
-how you can combine the general principles found in the Qi4j Core API package.
+how you can combine the general principles found in the Zest� Core API package.
== How to write a filter specification? ==
The filter transform takes a specification implementation which has a very simple method, isSatisfiedBy() (read more
http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/core/spi/src/docs/spi.txt
----------------------------------------------------------------------
diff --git a/core/spi/src/docs/spi.txt b/core/spi/src/docs/spi.txt
index 305449f..5b000ea 100644
--- a/core/spi/src/docs/spi.txt
+++ b/core/spi/src/docs/spi.txt
@@ -21,7 +21,7 @@
source=core/spi/dev-status.xml
--------------
-The Qi4j Core Runtime has a number of extension points, which we call the _Qi4j Core Extension SPI_. These are defined
+The Zest� Core Runtime has a number of extension points, which we call the _Qi4j Core Extension SPI_. These are defined
interfaces used *only* by the Core Runtime and *never* directly by application code. <<extensions>> are assembled in
applications during the bootstrap phase.
@@ -35,7 +35,7 @@ There are currently 5 Core SPI extensions;
* <<core-spi-indexing>>
* <<core-spi-metrics>>
-Qi4j Runtime Extensions implementations may depend on Qi4j Libraries, but Libraries are NOT ALLOWED to depend on
+Zest� Runtime Extensions implementations may depend on Zest� Libraries, but Libraries are NOT ALLOWED to depend on
Extensions. Applications code is NOT ALLOWED to depend on extensions. And application code SHOULD NOT depend on the
Core Extension SPI. If you think that is needed, please contact qi4j-dev forum at Google Groups, to see if your usecase
can be solved in a support manner, or that we need to extend the Core API to support it.
http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/core/spi/src/docs/valueserialization.txt
----------------------------------------------------------------------
diff --git a/core/spi/src/docs/valueserialization.txt b/core/spi/src/docs/valueserialization.txt
index c510d55..1d4b650 100644
--- a/core/spi/src/docs/valueserialization.txt
+++ b/core/spi/src/docs/valueserialization.txt
@@ -22,7 +22,7 @@
== Overview ==
-The Qi4j Core Runtime use ValueSerialization to provide string representation of ValueComposites via their `toString()`
+The Zest� Core Runtime use ValueSerialization to provide string representation of ValueComposites via their `toString()`
method, and, their instanciation from the very same representation via the `newValueFromSerializedState(..)` method of
the ValueBuilderFactory API.
http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/core/testsupport/src/docs/testsupport.txt
----------------------------------------------------------------------
diff --git a/core/testsupport/src/docs/testsupport.txt b/core/testsupport/src/docs/testsupport.txt
index 251f338..82d6ed9 100644
--- a/core/testsupport/src/docs/testsupport.txt
+++ b/core/testsupport/src/docs/testsupport.txt
@@ -21,15 +21,15 @@
source=core/testsupport/dev-status.xml
--------------
-Qi4j comes with classes to help with testing. For general development, only a couple of classes are of interest as the
+Zest� comes with classes to help with testing. For general development, only a couple of classes are of interest as the
others are mostly for EntityStore and Index/Query SPI implementations. There is also some mocking support, to allow
-some of Qi4j's unique aspects to be mocked, but since Qi4j is so flexible at a fine-granular level, we have found that
+some of Zest's unique aspects to be mocked, but since Zest� is so flexible at a fine-granular level, we have found that
mocking is seldom, if ever, needed.
include::../../build/docs/buildinfo/artifact.txt[]
== Your First Testcase ==
-In most cases, you will probably use the AbstractQi4jTest class to simplify starting a Qi4j test instance.
+In most cases, you will probably use the AbstractQi4jTest class to simplify starting a Zest� test instance.
[snippet,java]
--------------
@@ -37,7 +37,7 @@ source=tutorials/hello/src/test/java/org/qi4j/tutorials/hello/HelloTest.java
tag=step1
--------------
-This will do all the initialization of a Qi4j runtime instance and create a single layer with a single module in it.
+This will do all the initialization of a Zest� runtime instance and create a single layer with a single module in it.
What goes into that module is declared in the assembly() method;
[snippet,java]
http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/extensions/entitystore-voldemort/src/docs/es-voldemort.txt
----------------------------------------------------------------------
diff --git a/extensions/entitystore-voldemort/src/docs/es-voldemort.txt b/extensions/entitystore-voldemort/src/docs/es-voldemort.txt
index d31e3d1..5837bd1 100644
--- a/extensions/entitystore-voldemort/src/docs/es-voldemort.txt
+++ b/extensions/entitystore-voldemort/src/docs/es-voldemort.txt
@@ -41,7 +41,7 @@ tag=assembly
== Configuration ==
-Most of the configuration of Voldemort is available in the Qi4j Configuration Entity.
+Most of the configuration of Voldemort is available in the Zest� Configuration Entity.
[snippet,java]
----
http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/extensions/indexing-solr/src/docs/index-solr.txt
----------------------------------------------------------------------
diff --git a/extensions/indexing-solr/src/docs/index-solr.txt b/extensions/indexing-solr/src/docs/index-solr.txt
index d58c8a1..2f0ebd8 100644
--- a/extensions/indexing-solr/src/docs/index-solr.txt
+++ b/extensions/indexing-solr/src/docs/index-solr.txt
@@ -27,7 +27,7 @@ source=extensions/indexing-solr/dev-status.xml
Index/Query services backed by an embedded http://lucene.apache.org/solr/[Apache Solr Search].
-WARNING: Solr Index/Query service do not support the Qi4j Query API but only native Solr queries.
+WARNING: Solr Index/Query service do not support the Zest� Query API but only native Solr queries.
include::../../build/docs/buildinfo/artifact.txt[]
http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/extensions/indexing-sql/instructions.txt
----------------------------------------------------------------------
diff --git a/extensions/indexing-sql/instructions.txt b/extensions/indexing-sql/instructions.txt
index 3df88d8..5bed896 100644
--- a/extensions/indexing-sql/instructions.txt
+++ b/extensions/indexing-sql/instructions.txt
@@ -17,18 +17,18 @@
* under the License.
///////////////////////////////////////////////////////////////
-These instructions are for preparing your out-of-box PostgreSQL installation so it would be usable with PostgreSQL indexing of Qi4j.
+These instructions are for preparing your out-of-box PostgreSQL installation so it would be usable with PostgreSQL indexing of Zest.
1. Creating login role and database
-1.1. Using pgAdmin, connect to PostgreSQL database, and create database you intend to use to store Qi4j entity data, and login role for Qi4j application to use when it connects to database.
+1.1. Using pgAdmin, connect to PostgreSQL database, and create database you intend to use to store Zest� entity data, and login role for Zest� application to use when it connects to database.
1.1. Update these values into your .properties file, if necessary.
2. Adding ltree as type
-2.1. Using pgAdmin, connect to PostgreSQL database, and navigate to database which is intended to be used for Qi4j. (Click on it)
+2.1. Using pgAdmin, connect to PostgreSQL database, and navigate to database which is intended to be used for Zest. (Click on it)
2.2. Executing arbitary SQL queries should be possible, click that button (button with SQL text on it, next to trash bin).
2.3. This will open new window, erase any text which pgAdmin generates there for you.
2.4. Then navigate to your PostgreSQL installation directory, then into 'share', and then into 'contrib'. Open file 'ltree.sql' in your favorite text editor.
2.5. Select all text, copy it, and paste to SQL query window which you opened in stage 2.2.
-2.6. If you know what you are doing, you may change the line 'SET search_path = public;' to make search_path be 'pg_catalog', or name of schema that Qi4j application will use ('qi4j' by default). It's ok to leave it to 'public' though.
+2.6. If you know what you are doing, you may change the line 'SET search_path = public;' to make search_path be 'pg_catalog', or name of schema that Zest� application will use ('qi4j' by default). It's ok to leave it to 'public' though.
2.7. Hit F5 or go Query -> Execute Query to execute the SQL. It should print some notices into output window but no errors nor warnings should be present.
2.8. Ltree type should be now installed to your PostgreSQL installation.
http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/libraries/alarm/src/docs/alarm.txt
----------------------------------------------------------------------
diff --git a/libraries/alarm/src/docs/alarm.txt b/libraries/alarm/src/docs/alarm.txt
index 255cf07..996a9fe 100644
--- a/libraries/alarm/src/docs/alarm.txt
+++ b/libraries/alarm/src/docs/alarm.txt
@@ -34,7 +34,7 @@ consequences are to other systems when one fails. The _Alarm Point_ concepts bec
world of today, where _Alarm Points_ allows for fine-grained notification and view into the health of one or more
systems.
-In Qi4j, we are building upon this powerful abstraction, from decades of field experience.
+In Zest, we are building upon this powerful abstraction, from decades of field experience.
include::../../build/docs/buildinfo/artifact.txt[]
@@ -78,7 +78,7 @@ tag=documentation
--------------
== Alarm Models ==
-The Qi4j Alarm library comes with 3 _Alarm Models_ which should be sufficient for most uses. These are based on decades
+The Zest� Alarm library comes with 3 _Alarm Models_ which should be sufficient for most uses. These are based on decades
of experience from the industrial automation industry and user feedback.
== Simple Alarm Model ==
http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/libraries/circuitbreaker/src/docs/circuitbreaker.txt
----------------------------------------------------------------------
diff --git a/libraries/circuitbreaker/src/docs/circuitbreaker.txt b/libraries/circuitbreaker/src/docs/circuitbreaker.txt
index c06fa46..7b074a6 100644
--- a/libraries/circuitbreaker/src/docs/circuitbreaker.txt
+++ b/libraries/circuitbreaker/src/docs/circuitbreaker.txt
@@ -27,7 +27,7 @@ source=libraries/circuitbreaker/dev-status.xml
The Circuit Breaker library provides a way to guard your application
against faulty external systems (e.g. mail servers being down, web
-services being down). It is used by many Qi4j Extensions and Libraries.
+services being down). It is used by many Zest� Extensions and Libraries.
There's a couple of differences between this implementation and others
seen on the net, but we've also heavily borrowed from others. The
@@ -54,7 +54,7 @@ track service levels and see exception messages, and trip/enable circuit
breakers.
Fourth, if an external system is unavailable due to a circuitbreaker
-tripping it should be possible to expose this to other Qi4j services.
+tripping it should be possible to expose this to other Zest� services.
There is a standard implementation of the Availability interface that
delegates to a circuit breaker and the Enabled configuration flag, which
is what we'd suspect will be used in most cases where external systems
@@ -64,7 +64,7 @@ include::../../build/docs/buildinfo/artifact.txt[]
== Direct usage ==
-The CircuitBreaker can be used directly, even without using anything else from the Qi4j SDK.
+The CircuitBreaker can be used directly, even without using anything else from the Zest� SDK.
Here is a code snippet that demonstrate how to create a CircuitBreaker and how it behave:
http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/libraries/constraints/src/docs/constraints.txt
----------------------------------------------------------------------
diff --git a/libraries/constraints/src/docs/constraints.txt b/libraries/constraints/src/docs/constraints.txt
index 2514cf9..f0a7e59 100644
--- a/libraries/constraints/src/docs/constraints.txt
+++ b/libraries/constraints/src/docs/constraints.txt
@@ -26,7 +26,7 @@ source=libraries/constraints/dev-status.xml
--------------
The Constraints library provide a bunch of often used Constraints based on the
-Qi4j Constraints api described in <<def-constraint>>.
+Zest� Constraints api described in <<def-constraint>>.
Remember that you are not limited to constraints presents in this library, you
are encouraged to write your own constraints. See <<howto-create-constraint>>
http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/libraries/fileconfig/src/docs/fileconfig.txt
----------------------------------------------------------------------
diff --git a/libraries/fileconfig/src/docs/fileconfig.txt b/libraries/fileconfig/src/docs/fileconfig.txt
index 3cc115d..5baa0a4 100644
--- a/libraries/fileconfig/src/docs/fileconfig.txt
+++ b/libraries/fileconfig/src/docs/fileconfig.txt
@@ -27,7 +27,7 @@ source=libraries/fileconfig/dev-status.xml
The FileConfig library provide a service for accessing application-specific directories.
-A lot of the Qi4j Libraries and Extensions make use of this library to locate files.
+A lot of the Zest� Libraries and Extensions make use of this library to locate files.
include::../../build/docs/buildinfo/artifact.txt[]
http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/libraries/http/src/docs/http.txt
----------------------------------------------------------------------
diff --git a/libraries/http/src/docs/http.txt b/libraries/http/src/docs/http.txt
index fa8ecef..3c135dd 100644
--- a/libraries/http/src/docs/http.txt
+++ b/libraries/http/src/docs/http.txt
@@ -29,7 +29,7 @@ The HTTP library provides a Jetty based embedded HTTP service with support for e
filters assembly as Services.
It's an easy way to embedd a servlet container and reuse everything that can be run in it (JAX-*, Restlet, Wicket,
-Vaadin, GWT etc..). If instead you want to run a Qi4j Application in a servlet container, see <<library-servlet>>.
+Vaadin, GWT etc..). If instead you want to run a Zest� Application in a servlet container, see <<library-servlet>>.
include::../../build/docs/buildinfo/artifact.txt[]
@@ -90,7 +90,7 @@ tag=jmx
=== Configuration ===
-Underlying Jetty engine configuration is exposed as a Qi4j Service Configuration.
+Underlying Jetty engine configuration is exposed as a Zest� Service Configuration.
The only one that is mandatory is the port.
See org.qi4j.library.http.JettyConfiguration for a reference of all available
http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/libraries/jmx/src/docs/jmx.txt
----------------------------------------------------------------------
diff --git a/libraries/jmx/src/docs/jmx.txt b/libraries/jmx/src/docs/jmx.txt
index afb8493..4469048 100644
--- a/libraries/jmx/src/docs/jmx.txt
+++ b/libraries/jmx/src/docs/jmx.txt
@@ -25,7 +25,7 @@
source=libraries/jmx/dev-status.xml
--------------
-The JMX library provides a service that exposes a Qi4j app in
+The JMX library provides a service that exposes a Zest� app in
JMX automatically, giving you an opportunity to inspect the app much as
you would with the <<tools-envisage>> tool.
http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/libraries/lang-beanshell/README.txt
----------------------------------------------------------------------
diff --git a/libraries/lang-beanshell/README.txt b/libraries/lang-beanshell/README.txt
index 4cb1b55..1d47320 100644
--- a/libraries/lang-beanshell/README.txt
+++ b/libraries/lang-beanshell/README.txt
@@ -2,7 +2,7 @@
BeanShell is licensed under LGPL, and Apache Software Foundation
doesn't allow the use of LGPL in Apache projects.
-Therefor, Apache Zest had to drop this library component, but
+Therefor, Apache Zest� had to drop this library component, but
it is still available for separate download at
https://github.com/Qi4j/qi4j-sdk
http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/libraries/lang-jruby/README.txt
----------------------------------------------------------------------
diff --git a/libraries/lang-jruby/README.txt b/libraries/lang-jruby/README.txt
index 4cb1b55..1d47320 100644
--- a/libraries/lang-jruby/README.txt
+++ b/libraries/lang-jruby/README.txt
@@ -2,7 +2,7 @@
BeanShell is licensed under LGPL, and Apache Software Foundation
doesn't allow the use of LGPL in Apache projects.
-Therefor, Apache Zest had to drop this library component, but
+Therefor, Apache Zest� had to drop this library component, but
it is still available for separate download at
https://github.com/Qi4j/qi4j-sdk
http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/libraries/logging/src/docs/logging.txt
----------------------------------------------------------------------
diff --git a/libraries/logging/src/docs/logging.txt b/libraries/logging/src/docs/logging.txt
index 06d823a..dabe4e7 100644
--- a/libraries/logging/src/docs/logging.txt
+++ b/libraries/logging/src/docs/logging.txt
@@ -21,7 +21,7 @@
source=libraries/logging/dev-status.xml
--------------
-First of all, Qi4j is taking a fresh look at all things that we take for granted. Logging is one such thing.
+First of all, Zest� is taking a fresh look at all things that we take for granted. Logging is one such thing.
It should (but is not) obvious that Logging are used for three very distinct purposes, and in our opinion the concepts
are not related and should not be abstracted in the same fashion, as has been the norm in Log4j, JDK logging, Commons
@@ -80,7 +80,7 @@ visible.
== Tracing ==
Tracing is the process of tracking all the methods that has been called. There are two levels of tracing available in
-Qi4j. Either Trace All or trace where a annotation has been given.
+Zest. Either Trace All or trace where a annotation has been given.
If the TraceAllConcern is added to a composite, and there is a TraceService visible, then all method calls into that
composite is traced.
http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/libraries/osgi/src/docs/osgi.txt
----------------------------------------------------------------------
diff --git a/libraries/osgi/src/docs/osgi.txt b/libraries/osgi/src/docs/osgi.txt
index 2ed99a1..cee2129 100644
--- a/libraries/osgi/src/docs/osgi.txt
+++ b/libraries/osgi/src/docs/osgi.txt
@@ -25,12 +25,12 @@
source=libraries/osgi/dev-status.xml
--------------
-OSGi Library allows you to import OSGi services as Qi4j Services and to export Qi4j Services as OSGi Services both
-leveraging the Qi4j Availability and OSGi FallbackStrategy mechanisms.
+OSGi Library allows you to import OSGi services as Zest� Services and to export Zest� Services as OSGi Services both
+leveraging the Zest� Availability and OSGi FallbackStrategy mechanisms.
include::../../build/docs/buildinfo/artifact.txt[]
-== Export Qi4j services to an OSGi Bundle ==
+== Export Zest� services to an OSGi Bundle ==
[snippet,java]
----
@@ -39,7 +39,7 @@ tag=export
----
-== Import OSGi services in a Qi4j Module ==
+== Import OSGi services in a Zest� Module ==
[snippet,java]
----
http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/libraries/rest-client/src/docs/primer.txt
----------------------------------------------------------------------
diff --git a/libraries/rest-client/src/docs/primer.txt b/libraries/rest-client/src/docs/primer.txt
index 35a1121..6ed3a9d 100644
--- a/libraries/rest-client/src/docs/primer.txt
+++ b/libraries/rest-client/src/docs/primer.txt
@@ -20,7 +20,7 @@
[[library-rest-client-primer, HATEOAS Primer]]
= ReST - HATEOAS Primer
-The Qi4j ReST Client implements HATEOAS (Hypermedia As The Engine Of Application State) to the full extent intended
+The Zest� ReST Client implements HATEOAS (Hypermedia As The Engine Of Application State) to the full extent intended
by Roy Fielding. The ReST Client Library enables the creation of HATEOAS applications that are NOT using the URL space,
and it is NOT about doing RPC calls over HTTP using a common exchange format (like JSON).
@@ -79,7 +79,7 @@ case, such as doing a signup for the website, login, redirects to other servers,
It becomes possible to blend general application and error handling logic with use case specific handlers.
That's basically it. This is where I want to go with support for REST, as a way to truly leverage the REST ideas and
-make it very easy to do REST applications *and* clients based on Qi4j, by keeping the application logic on the server.
+make it very easy to do REST applications *and* clients based on Zest, by keeping the application logic on the server.
In the long run there would also be a JavaScript version of the client, with the same characteristics, so that you can
-easily build a jQuery UI for Qi4j REST apps.
+easily build a jQuery UI for Zest� REST apps.
http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/libraries/scheduler/src/docs/scheduler.txt
----------------------------------------------------------------------
diff --git a/libraries/scheduler/src/docs/scheduler.txt b/libraries/scheduler/src/docs/scheduler.txt
index 8b4b5ac..142907a 100644
--- a/libraries/scheduler/src/docs/scheduler.txt
+++ b/libraries/scheduler/src/docs/scheduler.txt
@@ -75,7 +75,7 @@ Tasks have a mandatory name property and an optional tags property. Theses prope
each TimelineRecord created when the Timeline feature is activated.
The run() method of Tasks is wrapped in a UnitOfWork when called by the Scheduler.
-Thanks to the UnitOfWork handling in Qi4j, you can split the work done in your Tasks in
+Thanks to the UnitOfWork handling in Zest, you can split the work done in your Tasks in
several UnitOfWorks, the one around the Task#run() invocation will then be paused.
Here is a simple example:
http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/libraries/servlet/src/docs/servlet.txt
----------------------------------------------------------------------
diff --git a/libraries/servlet/src/docs/servlet.txt b/libraries/servlet/src/docs/servlet.txt
index 22b60b4..48974ee 100644
--- a/libraries/servlet/src/docs/servlet.txt
+++ b/libraries/servlet/src/docs/servlet.txt
@@ -25,16 +25,16 @@
source=libraries/servlet/dev-status.xml
--------------
-This library provide the necessary boilerplate code to bootstrap a Qi4j Application in a Servlet container plus some
+This library provide the necessary boilerplate code to bootstrap a Zest� Application in a Servlet container plus some
facilities. It aims at a very simple need and is provided as an example integration.
-If instead you want to run a servlet container inside a Qi4j Application, see <<library-http>>.
+If instead you want to run a servlet container inside a Zest� Application, see <<library-http>>.
include::../../build/docs/buildinfo/artifact.txt[]
== Application Bootstrap ==
-Extends `AbstractQi4jServletBootstrap` to easily bind a Qi4j `Application` activation/passivation to your webapp
+Extends `AbstractQi4jServletBootstrap` to easily bind a Zest� `Application` activation/passivation to your webapp
lifecycle.
Use `Qi4jServletSupport#application(javax.servlet.ServletContext)` to get a handle on the `Application` from the
http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/libraries/shiro-core/src/docs/shiro.txt
----------------------------------------------------------------------
diff --git a/libraries/shiro-core/src/docs/shiro.txt b/libraries/shiro-core/src/docs/shiro.txt
index 3fd16b6..a12a3e7 100644
--- a/libraries/shiro-core/src/docs/shiro.txt
+++ b/libraries/shiro-core/src/docs/shiro.txt
@@ -35,20 +35,20 @@ cryptography, and session management. With Shiro’s easy-to-understand API, you
application – from the smallest mobile applications to the largest web and enterprise applications.'' says the Apache
Shiro website.
-Altough Apache Shiro can be used as-is with Qi4j Applications, this library provides integrations that can come in
+Altough Apache Shiro can be used as-is with Zest™ Applications, this library provides integrations that can come in
handy. If your use case do not fit any of theses integrations, look at their respective code. You should find out
pretty easily how to compose the provided code to write your integration. Don't hesitate to contribute interesting
integrations to this very library.
We invite you to read the comprehensive http://shiro.apache.org/documentation.html[Apache Shiro documentation], we will
-mostly discuss Qi4j related matters here.
+mostly discuss Zest™ related matters here.
include::../../build/docs/buildinfo/artifact.txt[]
== Basic usage ==
For standalone applications, you can use plain Shiro easily. The only thing to do is to register a configured
-SecurityManager when activating your Qi4j Application. It can be done outside the application, before its activation,
+SecurityManager when activating your Zest™ Application. It can be done outside the application, before its activation,
"à là" by-hand ;
[snippet,java]
@@ -78,7 +78,7 @@ tag=config
Remember that this setup use a ThreadLocal SecurityManager singleton. Among other things it means that, althoug the
IniSecurityManagerService is activated on Application activation, if you need to use Shiro in other Services that are
-activated on Application activation you should tell Qi4j about this dependency by injecting the SecurityManagerService
+activated on Application activation you should tell Zest™ about this dependency by injecting the SecurityManagerService
in the laters.
Once started you must remember to register the SecurityManager in Shiro's ThreadContext ;
@@ -116,10 +116,10 @@ Apache Shiro annotations:
All the above is sufficient as long as you use the ini file to store user credentials and permissions or a Realm that
has no dependency on your application code and can be specified in the ini file to be instanciated by Shiro outside the
-Qi4j scope.
+Zest™ scope.
One usecase where it's not sufficient comes quickly as you would like to provide user credentials and permissions
-from Entities stored in an EntityStore or perform any custom logic involving your Qi4j Application.
+from Entities stored in an EntityStore or perform any custom logic involving your Zest™ Application.
Let's look at a complete example using a Realm Service that extends one of the Shiro provided Realm which use in-memory
credientials and configuring it ;
@@ -235,7 +235,7 @@ libraries. There's support for text files, simple JDBC, LDAP, CAS SSO, OAuth, Op
Take the PasswordRealmService as a start and extend/rewrite it to suit your needs.
-If you happen to come with a Qi4j integration that could be valuable in this very library, don't hesitate to
+If you happen to come with a Zest™ integration that could be valuable in this very library, don't hesitate to
contribute.
http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/libraries/shiro-web/src/docs/shiro-web.txt
----------------------------------------------------------------------
diff --git a/libraries/shiro-web/src/docs/shiro-web.txt b/libraries/shiro-web/src/docs/shiro-web.txt
index 8797976..c92d9b8 100644
--- a/libraries/shiro-web/src/docs/shiro-web.txt
+++ b/libraries/shiro-web/src/docs/shiro-web.txt
@@ -37,16 +37,16 @@ application – from the smallest mobile applications to the largest web and ent
Shiro website.
We invite you to read the comprehensive http://shiro.apache.org/documentation.html[Apache Shiro documentation], we will
-mostly discuss Qi4j related matters here.
+mostly discuss Zest™ related matters here.
include::../../build/docs/buildinfo/artifact.txt[]
== Servlet Context ==
-In a servlet context, being through the <<library-servlet>>, the <<library-http>> or your custom Qi4j application
+In a servlet context, being through the <<library-servlet>>, the <<library-http>> or your custom Zest™ application
bootstrap, plain Shiro is usable. A WebEnvironment must be globally available and ShiroFilter must be registered.
-If you use a custom Qi4j application boostrap or the <<library-servlet>> you can directly use Shiro's provided
+If you use a custom Zest™ application boostrap or the <<library-servlet>> you can directly use Shiro's provided
EnvironmentLoaderListener and ShiroFilter.
If you use the <<library-http>> you can either directly use Shiro classes or use the assembly API as follows:
http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/libraries/spring/src/docs/spring.txt
----------------------------------------------------------------------
diff --git a/libraries/spring/src/docs/spring.txt b/libraries/spring/src/docs/spring.txt
index 19c0cca..458eb99 100644
--- a/libraries/spring/src/docs/spring.txt
+++ b/libraries/spring/src/docs/spring.txt
@@ -27,14 +27,14 @@ source=libraries/spring/dev-status.xml
include::../../build/docs/buildinfo/artifact.txt[]
-== Using Spring Framework in Apache Zest ==
-Zest supports that Spring Application Context is imported into the Zest runtime, and the declared Spring
-beans will be available as Zest services. The most important things to remember are;
+== Using Spring Framework in Apache Zest� ==
+Zest� supports that Spring Application Context is imported into the Zest� runtime, and the declared Spring
+beans will be available as Zest� services. The most important things to remember are;
1. Only Spring Singletons are currently supported.
- 2. One ApplicationContext per Zest Module.
- 3. The Zest service will be given the same name as the Spring Bean name.
- 4. Zest Configuration is not reacbable from the Spring bean (kind of obvious).
+ 2. One ApplicationContext per Zest� Module.
+ 3. The Zest� service will be given the same name as the Spring Bean name.
+ 4. Zest� Configuration is not reacbable from the Spring bean (kind of obvious).
[snippet,java]
----
@@ -42,10 +42,10 @@ source=libraries/spring/src/test/java/org/qi4j/library/spring/importer/Qi4jImpor
tag=import
----
-== Using Apache Zest in Spring Framework ==
-It is also possible to run a Zest Application as a Spring Bean and export its Services to Spring.
+== Using Apache Zest� in Spring Framework ==
+It is also possible to run a Zest� Application as a Spring Bean and export its Services to Spring.
-Steps to export Qi4j service:
+Steps to export Zest� service:
1. Create spring BeanFactory service of qi4j services to export.
2. Create a class that extends Qi4jApplicationBootstrap.
@@ -54,7 +54,7 @@ Steps to export Qi4j service:
5. Sets the identity of bean factory service. This identity is the spring bean name.
6. Declare qi4j bootstrap in spring xml application context.
-To bootstrap the Zest runtime in Spring, you should have a bootstrap bean that extends the
+To bootstrap the Zest� runtime in Spring, you should have a bootstrap bean that extends the
+org.qi4j.library.spring.bootstrap.Qi4jApplicationBootstrap+ and implement the
+org.springframework.context.ApplicationContextAware+.
http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/libraries/sql/src/docs/sql.txt
----------------------------------------------------------------------
diff --git a/libraries/sql/src/docs/sql.txt b/libraries/sql/src/docs/sql.txt
index abbac47..9116718 100644
--- a/libraries/sql/src/docs/sql.txt
+++ b/libraries/sql/src/docs/sql.txt
@@ -142,7 +142,7 @@ include::../test/resources/testds.properties[]
=== Importing an existing DataSource ===
-Importing an existing DataSource at assembly time is usefull when your Qi4j
+Importing an existing DataSource at assembly time is usefull when your Zest
Application runs in an environment where DataSource are already provided.
[snippet,java]
http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/72a43f3c/manual/src/docs/tutorials/howto-assembly-application.txt
----------------------------------------------------------------------
diff --git a/manual/src/docs/tutorials/howto-assembly-application.txt b/manual/src/docs/tutorials/howto-assembly-application.txt
index dcb520c..31a8e5b 100644
--- a/manual/src/docs/tutorials/howto-assembly-application.txt
+++ b/manual/src/docs/tutorials/howto-assembly-application.txt
@@ -27,9 +27,9 @@ At runtime you will need the Core Runtime artifact too. See the <<howto-depend-o
== Basics ==
-First let's recap the structural requirements of Qi4j;
+First let's recap the structural requirements of Zest;
- * There is one and only one Application instance per Qi4j Runtime.
+ * There is one and only one Application instance per Zest� Runtime.
* Every Application must contain one or more Layers.
* All Composites must be declared in one or more Modules.
* Each Module belong to a Layer.
@@ -40,7 +40,7 @@ Ok, that was quite a handful. Let's look at them one by one.
== Application ==
-The first one means that for each Qi4j Runtime you start, there will be exactly one application. As far as we know, Qi4j
+The first one means that for each Zest� Runtime you start, there will be exactly one application. As far as we know, Zest
is fully isolated, meaning there are no static members being populated and such.
== Layers ==
@@ -49,7 +49,7 @@ Layers are the super-structures of an application. We have been talking about th
whiteboards (or even black boards for those old enough), and sometimes organized the codebases along such boundaries.
But, there has been little effort to enforce the Layer mechanism in code, although it is an extremely powerful
construct. First of all it implies directional dependency and a high degree of order, spagetti code is reduced if
-successfully implemented. For Qi4j, it means that we can restrict access to Composite and Object declarations, so that
+successfully implemented. For Zest, it means that we can restrict access to Composite and Object declarations, so that
higher layers can not reach them incidentally. You can enforce architecture to a high degree. You can require all
creation of composites to go through an exposed Factory, which doesn't require the Composite to be public. And so on.
Layers have hierarchy, i.e. one layer is top of one or more layers, and is below one or more layers, except for the
@@ -58,7 +58,7 @@ that are both the top and bottom.
== Modules ==
-The Module concept has also been around forever. And in Qi4j we also makes the Modules explicit. Each Module belong to a
+The Module concept has also been around forever. And in Zest� we also makes the Modules explicit. Each Module belong to a
Layer, and for each Module you declare the Composite and Object types for that Module, together with a Visibility rule,
one of; application, layer, module.
@@ -109,7 +109,7 @@ acting addiction).
How to structure your code is beyond the scope of this section. If you are an experienced designer, you will have done
that before, and you may have started out with good intentions at times only to find yourself in a spaghetti swamp
later, or perhaps in the also famous "Clear as Clay" or "Ball (bowl?) of Mud". Either way, you need to draw on your
-experience and come up with good structure that Qi4j lets you enforce.
+experience and come up with good structure that Zest� lets you enforce.
So, for the sake of education, we are going to look at an application that consists of many layers, each with a few
modules. See picture below.
@@ -127,7 +127,7 @@ tag=main
-----------
The above is the basic setup on how to structure a real-world applicaton, unless you intend to mess with the
-implementations of various Qi4j systems (yes there are hooks for that too), but that is definitely beyond the scope of
+implementations of various Zest� systems (yes there are hooks for that too), but that is definitely beyond the scope of
this tutorial.
Now, the createXyzLayer() methods were excluded to keep the sample crisp and easy to follow. Let's take a look at what
@@ -158,5 +158,5 @@ source=manual/src/main/java/org/qi4j/manual/recipes/assemble/Main.java
tag=shutdown
-----------
-This concludes this tutorial. We have looked how to get the initial Qi4j runtime going, how to declare the assembly
+This concludes this tutorial. We have looked how to get the initial Zest� runtime going, how to declare the assembly
for application model creation and finally the activation of the model itself.