Merge pull request #11 from dancergraham/feature/factory

Feature/factory
Doc: Code running instructions

Author: dancergraham

chapter01_strategy/readme.md

@@ -1,6 +1,6 @@
 # Chapter 1: Strategy design pattern
 
-> **Strategy**: defines a family of algorithms, encapsulates each one and makes them interchangeable. 
+> **Strategy**: defines a family of algorithms, encapsulates each one and makes them interchangeable.
 > Strategy lets the algorithm vary independently of clients that use it.
 
 ### Class Diagram
@@ -26,7 +26,6 @@ Strategy "1" <|.. "*" ConcreteStrategyB
     }
 ```
 
-
 ## Use in Python
 
 The more pythonic approach in my mind is to define methods within an appropriate namespace
@@ -35,8 +34,15 @@ this does not violate the above definition. The class-based approach is
 needed in Java and has the advantage of explicitly setting out the required
 method in an abstract base class.
 
-An example from the standard lib is changing the text [completion method](https://docs.python.org/3/library/readline.html?highlight=set_#readline.set_completer)
+An example from the standard lib is changing the
+text [completion method](https://docs.python.org/3/library/readline.html?highlight=set_#readline.set_completer)
 from the readline module. This is used by the python REPL when we hit <button>TAB</button> in the REPL.
 We can change the completion behavior via the `set_completer()` method, which takes a function
-which replaces the current completion function. The function is used explicitly to set 
-the required behavior.  
+which replaces the current completion function. The function is used explicitly to set
+the required behavior.
+
+## Running the code
+
+```bash
+python duck.py
+```

chapter02_observer/readme.md

@@ -3,8 +3,14 @@
 > **Observer**: defines a one-to-many dependency between objects so that when one object changes state, all of its
 > dependents are notified and updated automatically.
 
-A very useful design pattern, often used in user interfaces 
-and as part of the popular Model-View-Controller (MVC) pattern used, 
+A very useful design pattern, often used in user interfaces
+and as part of the popular Model-View-Controller (MVC) pattern used,
 for instance, in Django.
-As I wrote out the code I found it very appealing that I did not need 
+As I wrote out the code I found it very appealing that I did not need
 to change the subject at all to add new observers.
+
+## Running the code
+
+```bash
+python weather.py
+```

chapter03_decorator/readme.md

@@ -17,3 +17,4 @@ it just serves as documentation.
 ```bash
 python coffee.py
 ```
+

chapter04_factory/pizza_abstract_factory.py

@@ -11,6 +11,11 @@ def __str__(self):
         return "Shredded Mozzarella"
 
 
+class ParmesanCheese(Cheese):
+    def __str__(self):
+        return "Shredded Parmesan"
+
+
 class ReggianoCheese(Cheese):
     def __str__(self):
         return "Reggiano Cheese"
@@ -112,22 +117,22 @@ def __str__(self) -> str:
 
 
 class PizzaIngredientFactory(abc.ABC):
-    def create_dough():
+    def create_dough(self):
         raise NotImplementedError
 
-    def create_sauce():
+    def create_sauce(self):
         raise NotImplementedError
 
-    def create_cheese():
+    def create_cheese(self):
         raise NotImplementedError
 
-    def create_veggies():
+    def create_veggies(self):
         raise NotImplementedError
 
-    def create_pepperoni():
+    def create_pepperoni(self):
         raise NotImplementedError
 
-    def create_clam():
+    def create_clam(self):
         raise NotImplementedError
 
 
@@ -264,8 +269,8 @@ class PizzaStore:
     def create_pizza(self, item):
         raise NotImplementedError
 
-    def order_pizza(self, type):
-        pizza = self.create_pizza(type)
+    def order_pizza(self, type_):
+        pizza = self.create_pizza(type_)
         print(f"--- Making a {pizza.name} ---")
         pizza.prepare()
         pizza.bake()

chapter04_factory/readme.md

@@ -2,14 +2,30 @@
 
 > **Simple Factory**: A class which chooses which product class to instantiate and return, based upon method parameters.
 
-The Python standard library contains multiple references to factory objects, for instances in [dataclasses](https://docs.python.org/3/library/dataclasses.html?highlight=factory)
+The Python standard library contains multiple references to factory objects, for instances
+in [dataclasses](https://docs.python.org/3/library/dataclasses.html?highlight=factory).
+The Factory Boy package provides easy object creation for Django
+and for other ORMs.
 
-> **Factory Method**: Defines an interface for creating an object, but lets subclasses decide which class to instantiate. The Factory method lets a class defer instantiation to subclasses.
+> **Factory Method**: Defines an interface for creating an object, but lets subclasses decide which class to
+> instantiate. The Factory method lets a class defer instantiation to subclasses.
 
-For instance the `PizzaStore` abstract class in this repo provides an abstract `create_pizza` interface for creating one product.
+For instance the `PizzaStore` abstract class in this repo provides an abstract `create_pizza` interface for creating one
+product.
 
-The [python-qrcode](https://github.com/dancergraham/python-qrcode) module uses the factory method pattern nicely to separate only the part of the code that changes (generating png, svg, etc) from the underlying logic of the code generation and to allow extension through the creation of new factory methods without modification of the existing code.  I took advantage of this to add a new class for the creation of 3D QR codes with my favourite NURBS modelling software Rhino.
+The [python-qrcode](https://github.com/dancergraham/python-qrcode) module uses the factory method pattern nicely to
+separate only the part of the code that changes (generating png, svg, etc.) from the underlying logic of the code
+generation and to allow extension through the creation of new factory methods without modification of the existing code.
+I took advantage of this to add a new class for the creation of 3D QR codes with my favourite NURBS modelling software
+Rhino.
 
-> **Abstract Factory**: Provides an interface for creating families of related or dependent objects without specifying their concrete classes.
+> **Abstract Factory**: Provides an interface for creating families of related or dependent objects without specifying
+> their concrete classes.
 
 For instance the `PizzaIngredientFactory` abstract class defines an interface for a family of products.
+
+## Running the code
+
+```bash
+python pizza_abstract_factory.py
+```

chapter05_singleton/readme.md

@@ -2,4 +2,11 @@
 
 > **Singleton**: ensures a class has only one instance, and provides a global point of access to it.
 
-My implementation is based this [stackoverflow post](https://stackoverflow.com/questions/6760685/creating-a-singleton-in-python?noredirect=1&lq=1).
+My implementation is based
+this [stackoverflow post](https://stackoverflow.com/questions/6760685/creating-a-singleton-in-python?noredirect=1&lq=1).
+
+## Running the code
+
+```bash
+python chocolate.py
+```

chapter06_command/readme.md

@@ -1,7 +1,18 @@
 # Chapter 6: Command design pattern
 
-> **Command**: Encapsulates a request as an object, thereby letting you parameterise clients with different requests, queue or log requests, and support undoable operations.
+> **Command**: Encapsulates a request as an object, thereby letting you parameterize clients with different requests,
+> queue or log requests, and support undoable operations.
 
 ## Use in Python
 
-[Threading](https://docs.python.org/3/library/threading.html) In the Python standard library follows the command design pattern: The _Client_ is the main thread and the _receiver_ is the target thread.  The _Command_ is a callable Python object which is executed by calling its `__call__()` method. The _Invoker_ is the `Thread` instance and its `run()` method is equivalent to calling _execute_ in the Command pattern. `Thread`'s `run` method can be overridden in subclasses to customise the functionality beyond simply providing a function and input `args` and `kwargs`.
+[Threading](https://docs.python.org/3/library/threading.html) In the Python standard library follows the command design
+pattern: The _Client_ is the main thread and the _receiver_ is the target thread. The _Command_ is a callable Python
+object which is executed by calling its `__call__()` method. The _Invoker_ is the `Thread` instance and its `run()`
+method is equivalent to calling _execute_ in the Command pattern. `Thread`'s `run` method can be overridden in
+subclasses to customise the functionality beyond simply providing a function and input `args` and `kwargs`.
+
+## Running the code
+
+```bash
+python remote_undo.py
+```

chapter07_adapter_facade/readme.md

@@ -1,12 +1,23 @@
-# Chapter 7: Adapter and Façade design patterns
+# Chapter 7: Adapter and Facade design patterns
 
-I find myself using the adapter and facade patterns a lot when refactoring existing code. I know how I want it to work and I know how it works now but I don't have time _right now_ to fix it so I add an adapter or facade to give it a clean interface and I only change the underlying code if I need to make significant changes to the underlying implementation.
+I find myself using the adapter and facade patterns a lot when refactoring existing code. I know how I want it to work
+and I know how it works now, but I don't have time _right now_ to fix it, so I add an adapter or facade to give it a clean
+interface and I only change the underlying code if I need to make significant changes to the underlying implementation.
 
-> **Adapter**: Converts the interface of a class into another interface the clients expect. Adapter lets classes work together that couldn't otherwise because of incompatible interfaces.
+> **Adapter**: Converts the interface of a class into another interface the clients expect. Adapter lets classes work
+> together that couldn't otherwise because of incompatible interfaces.
 
-Compiled C modules in Python could be seen as examples of the adapter pattern: the Python implementation provides an interface for python code to work with the incompatible underlying C code.
+Compiled C modules in Python could be seen as examples of the adapter pattern: the Python implementation provides an
+interface for python code to work with the incompatible underlying C code.
 
-> **Façade**: Provides a unified interface to a set of interfaces in a subsystem.  Façade defines a higher-level interface that makes the subsystem easier to use.
+> **Facade**: Provides a unified interface to a set of interfaces in a subsystem. Facade defines a higher-level
+> interface that makes the subsystem easier to use.
 
-The [pathlib](https://github.com/python/cpython/blob/main/Lib/pathlib.py) Python library provides a simplified high-level cross-platform interface to methods and attributes from the `os`, `sys`, `io` and other modules.
- 
+The [pathlib](https://github.com/python/cpython/blob/main/Lib/pathlib.py) Python library provides a simplified
+high-level cross-platform interface to methods and attributes from the `os`, `sys`, `io` and other modules.
+
+## Running the code
+
+```bash
+python duck.py
+```

chapter08_template/readme.md

@@ -7,3 +7,9 @@ Variants of the template pattern are found throughout the Python object model, f
 ## Template method in Django
 
 The template design pattern is widely used in frameworks such as Django, providing base classes which can be extended to provide required methods. For instance the [`full_clean`](https://github.com/django/django/blob/0dd29209091280ccf34e07c9468746c396b7778e/django/forms/forms.py#L424) method on Django forms runs the `_clean_fields()`, `self._clean_form()` and `self._post_clean()` methods, the latter of which is a *hook* for additional model validation and cleaning after the built-in validation logic has been applied.    
+
+## Running the code
+
+```bash
+python barista.py
+```

chapter09_iterator_composite/readme.md

@@ -1,11 +1,24 @@
 # Chapter 9: Iterator and Composite design patterns
 
-> **Iterator Method**: provides a way to access the elements of an aggregate object sequentially without exposing its underlying representation.
+> **Iterator Method**: provides a way to access the elements of an aggregate object sequentially without exposing its
+> underlying representation.
 
-Java offers either the "Look Before You Leap" (LBYL) philosophy or the "Easier to Ask for Forgiveness than for Permission"(EAFP) with its [`iterator`](https://docs.oracle.com/javase/8/docs/api/java/util/Iterator.html) interface: The former involves calling `hasNext()` prior to calling `next()` whilst the latter uses the more recent `forEachRemaining()` method.
+Java offers either the "Look Before You Leap" (LBYL) philosophy or the "Easier to Ask for Forgiveness than for
+Permission"(EAFP) with its [`iterator`](https://docs.oracle.com/javase/8/docs/api/java/util/Iterator.html) interface:
+The former involves calling `hasNext()` prior to calling `next()` whilst the latter uses the more
+recent `forEachRemaining()` method.
 
 Iteration is built in to the Python object model.
 
-Python requires only the `__iter__()` method to be implemented for an object to return `True` to `isinstance(obj, Iterable)`, however if an object implements just `__getitem__()` without `__iter__` then it will function as an iterable in Cpython!
+Python requires only the `__iter__()` method to be implemented for an object to return `True`
+to `isinstance(obj, Iterable)`, however if an object implements just `__getitem__()` without `__iter__` then it will
+function as an iterable in Cpython!
 
-> **Composite Pattern**: allows you to compose objects into tree structures to represent whole-part hierarchies.  Composite lets clients treat individual objects and compositions of objects uniformly.
+> **Composite Pattern**: allows you to compose objects into tree structures to represent whole-part hierarchies.
+> Composite lets clients treat individual objects and compositions of objects uniformly.
+
+## Running the code
+
+```bash
+python menus.py
+```

chapter10_state/readme.md

@@ -2,4 +2,12 @@
 
 > **State Pattern**: allows an object to alter its behaviour when its internal state changes.
 
-The class structure is the same as the Strategy Design Pattern but the intent is different : In the State pattern the subclasses represent specific application states and may cover multiple attributes and methods whereas Strategy allows an algorithm to be selected upon arbitrary criteria and would typically just apply to a single method.
+The class structure is the same as the Strategy Design Pattern but the intent is different : In the State pattern the
+subclasses represent specific application states and may cover multiple attributes and methods whereas Strategy allows
+an algorithm to be selected upon arbitrary criteria and would typically just apply to a single method.
+
+## Running the code
+
+```bash
+python gumballstate.py
+```