Update patterns details

Author: zoltantothcom

src/static/patterns/behavioral_chainOfResponsibility.js

@@ -2,7 +2,10 @@ const CHAIN_OF_RESPONSIBILITY = {
   id: 'chain_of_responsibility',
   name: 'Chain of Responsibility',
   type: 'behavioral',
-  hint: 'delegates commands to a chain of processing objects',
+  hint: 'A way of passing a request between a chain of objects',
+  definition: `Avoid coupling the sender of a request to its receiver by giving more than one object a chance to
+    handle the request. Chain the receiving objects and pass the request along the chain until an object handles it.`,
+  when: 'more than one object can handle a request and that information is known in runtime',
   codeES5: `function ShoppingCart() {
   this.products = [];
 

src/static/patterns/behavioral_command.js

@@ -2,7 +2,11 @@ const COMMAND = {
   id: 'command',
   name: 'Command',
   type: 'behavioral',
-  hint: 'creates objects which encapsulate actions and parameters',
+  hint: 'Encapsulate a command request as an object',
+  definition: `Encapsulate a request as an object, thereby letting you parameterize clients with different requests,
+    queue or log requests, and support undoable operations.`,
+  when:
+    'you have a queue of requests to handle or you want to log them. Also when you want to have an «undo» action',
   codeES5: `function Cockpit(instruction) {
   this.instruction = instruction;
 }

src/static/patterns/behavioral_interpreter.js

@@ -2,7 +2,11 @@ const INTERPRETER = {
   id: 'interpteter',
   name: 'Interpreter',
   type: 'behavioral',
-  hint: 'implements a specialized language',
+  hint: 'A way to include language elements in a program',
+  definition: `Given a language, define a representation for its grammar along with an interpreter that
+    uses the representation to interpret sentences in the language.`,
+  when:
+    'you want to interpret given language and you can represent statements as an abstract syntax trees',
   codeES5: `function Sum(left, right) {
   this.left = left;
   this.right = right;

src/static/patterns/behavioral_iterator.js

@@ -2,8 +2,10 @@ const ITERATOR = {
   id: 'iterator',
   name: 'Iterator',
   type: 'behavioral',
-  hint:
-    'accesses the elements of an object sequentially without exposing its underlying representation',
+  hint: 'Sequentially access the elements of a collection',
+  definition: `Provide a way to access the elements of an aggregate object sequentially
+    without exposing its underlying representation.`,
+  when: "you want to access object's content without knowing how it is internally represented",
   codeES5: `function Pattern(el) {
   this.index = 0;
   this.elements = el;

src/static/patterns/behavioral_mediator.js

@@ -2,8 +2,11 @@ const MEDIATOR = {
   id: 'mediator',
   name: 'Mediator',
   type: 'behavioral',
-  hint:
-    'allows loose coupling between classes by being the only class that has detailed knowledge of their methods',
+  hint: 'Defines simplified communication between classes',
+  definition: `Define an object that encapsulates how a set of objects interact.
+    Mediator promotes loose coupling by keeping objects from referring to each other explicitly,
+    and it lets you vary their interaction independently.`,
+  when: 'a set of objects communicate in structured but complex ways',
   codeES5: `function TrafficTower() {
   this.airplanes = [];
 }

src/static/patterns/behavioral_memento.js

@@ -2,7 +2,10 @@ const MEMENTO = {
   id: 'memento',
   name: 'Memento',
   type: 'behavioral',
-  hint: 'provides the ability to restore an object to its previous state',
+  hint: "Capture and restore an object's internal state",
+  definition: `Without violating encapsulation, capture and externalize an object's internal state
+    so that the object can be restored to this state later.`,
+  when: 'you need to take a snapshot of an object',
   codeES5: `function Pattern(value) {
   this.value = value;
 }

src/static/patterns/behavioral_observer.js

@@ -2,7 +2,10 @@ const OBSERVER = {
   id: 'observer',
   name: 'Observer',
   type: 'behavioral',
-  hint: 'is a publish/subscribe pattern which allows a number of observer objects to see an event',
+  hint: 'A way of notifying change to a number of classes',
+  definition: `Define a one-to-many dependency between objects so that when one object changes state,
+    all its dependents are notified and updated automatically.`,
+  when: 'a change to one object requires changing others',
   codeES5: `function Product() {
   this.price = 0;
   this.actions = [];

src/static/patterns/behavioral_state.js

@@ -2,7 +2,10 @@ const STATE = {
   id: 'state',
   name: 'State',
   type: 'behavioral',
-  hint: 'allows an object to alter its behavior when its internal state changes',
+  hint: "Alter an object's behavior when its state changes",
+  definition: `Allow an object to alter its behavior when its internal state changes.
+    The object will appear to change its class.`,
+  when: `the object's behaviour depends on its state and its behaviour changes in run-time depends on that state`,
   codeES5: `function Order() {
   this.pattern = new WaitingForPayment();
 

src/static/patterns/behavioral_strategy.js

@@ -2,7 +2,11 @@ const STRATEGY = {
   id: 'strategy',
   name: 'Strategy',
   type: 'behavioral',
-  hint: 'allows one of a family of algorithms to be selected on-the-fly at runtime',
+  hint: 'Encapsulates an algorithm inside a class',
+  definition: `Define a family of algorithms, encapsulate each one, and make them interchangeable.
+    Strategy lets the algorithm vary independently from clients that use it.`,
+  when: `you have many classes that differ in their behaviour.
+    Strategies allow to configure a class with one of many behaviours`,
   codeES5: `function ShoppingCart(discount) {
   this.discount = discount;
   this.amount = 0;

src/static/patterns/behavioral_template.js

@@ -2,8 +2,10 @@ const TEMPLATE = {
   id: 'template',
   name: 'Template',
   type: 'behavioral',
-  hint:
-    'defines the skeleton of an algorithm as an abstract class, allowing its subclasses to provide concrete behavior',
+  hint: 'Defer the exact steps of an algorithm to a subclass',
+  definition: `Define the skeleton of an algorithm in an operation, deferring some steps to subclasses.
+    Template Method lets subclasses redefine certain steps of an algorithm without changing the algorithm's structure.`,
+  when: `you have to define steps of the algorithm once and let subclasses to implement its behaviour`,
   codeES5: `function Tax() {}
 
 Tax.prototype.calc = function(value) {