[groovy] branch master updated: generate uml inline (Strategy pattern)

[pa...@apache.org]

This is an automated email from the ASF dual-hosted git repository.

paulk pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/groovy.git


The following commit(s) were added to refs/heads/master by this push:
     new 6a8a2dd  generate uml inline (Strategy pattern)
6a8a2dd is described below

commit 6a8a2dd7ea142e87e685b0d00a5cfa290becf69c
Author: Paul King <pa...@asert.com.au>
AuthorDate: Sun Aug 23 15:08:51 2020 +1000

    generate uml inline (Strategy pattern)
---
 src/spec/doc/assets/img/StrategyClasses.gif        | Bin 7448 -> 0 bytes
 src/spec/doc/fragment_design-pattern-strategy.adoc |  35 ++++++++++++++++++++-
 2 files changed, 34 insertions(+), 1 deletion(-)

diff --git a/src/spec/doc/assets/img/StrategyClasses.gif b/src/spec/doc/assets/img/StrategyClasses.gif
deleted file mode 100644
index 87a8b7a..0000000
Binary files a/src/spec/doc/assets/img/StrategyClasses.gif and /dev/null differ
diff --git a/src/spec/doc/fragment_design-pattern-strategy.adoc b/src/spec/doc/fragment_design-pattern-strategy.adoc
index 5d54a7b..7fbdd06 100644
--- a/src/spec/doc/fragment_design-pattern-strategy.adoc
+++ b/src/spec/doc/fragment_design-pattern-strategy.adoc
@@ -23,7 +23,40 @@
 
 The http://en.wikipedia.org/wiki/Strategy_pattern[Strategy Pattern] allows you to abstract away particular algorithms from their usage. This allows you to easily swap the algorithm being used without having to change the calling code. The general form of the pattern is:
 
-image::assets/img/StrategyClasses.gif[]
+[plantuml, StrategyClasses, png]
+....
+hide fields
+hide <<Hidden>> circle
+skinparam ClassBorderColor<<Hidden>> Transparent
+skinparam ClassBackgroundColor<<Hidden>> Transparent
+skinparam ClassStereotypeFontColor<<Hidden>> Transparent
+skinparam ClassFontSize<<Hidden>> 24
+skinparam ClassFontStyle<<Hidden>> bold
+skinparam shadowing<<Hidden>> false
+class Context {
+    +Strategy getStrategy()
+}
+class Strategy {
+    +algorithmMethod()
+}
+class ConcreteStrategy1 {
+    +algorithmMethod()
+}
+class ConcreteStrategy2 {
+    +algorithmMethod()
+}
+class "..." as ConcreteHidden
+class ConcreteHidden <<Hidden>> {
+}
+class ConcreteStrategyN {
+    +algorithmMethod()
+}
+Context o---r--- Strategy
+Strategy <|-- ConcreteStrategy1
+Strategy <|-- ConcreteStrategy2
+Strategy <|-[hidden]- ConcreteHidden
+Strategy <|-- ConcreteStrategyN
+....
 
 In Groovy, because of its ability to treat code as a first class object using anonymous methods (which we loosely call __Closures__), the need for the strategy pattern is greatly reduced. You can simply place algorithms inside Closures.