Further simplifications to builder pattern

Author: spookylukey

creational/builder.py

@@ -10,14 +10,20 @@
 from its actual representation (generally for abstraction).
 
 *What does this example do?
-This particular example uses a director function to abstract the
-construction of a building. The user specifies a Builder (House or
-Flat) and the director specifies the methods in the order necessary,
-creating a different building depending on the specification 
-(from the Builder class).
 
-@author: Diogenes Augusto Fernandes Herminio <[email protected]>
-https://gist.github.com/420905#file_builder_python.py
+The first example achieves this by using an abstract base
+class for a building, where the initializer (__init__ method) specifies the
+steps needed, and the concrete subclasses implement these steps.
+
+In other programming languages, a more complex arrangement is sometimes
+necessary. In particular, you cannot have polymorphic behaviour in a
+constructor in C++ - see https://stackoverflow.com/questions/1453131/how-can-i-get-polymorphic-behavior-in-a-c-constructor
+- which means this Python technique will not work. The polymorphism
+required has to be provided by an external, already constructed
+instance of a different class.
+
+In general, in Python this won't be necessary, but a second example showing
+this kind of arrangement is also included.
 
 *Where is the pattern used practically?
 
@@ -29,67 +35,80 @@
 """
 
 
-defconstruct_building(builder):
-builder.new_building()
-builder.build_floor()
-builder.build_size()
-returnbuilder.building
-
-
-# Abstract Builder
-classBuilder(object):
+# Abstract Building
+classBuilding(object):
 
 def__init__(self):
-self.building=None
-
-defnew_building(self):
-self.building=Building()
+self.build_floor()
+self.build_size()
 
 defbuild_floor(self):
 raiseNotImplementedError
 
 defbuild_size(self):
 raiseNotImplementedError
 
-# Concrete Builder
+def__repr__(self):
+return'Floor:{0.floor} | Size:{0.size}'.format(self)
 
 
-classBuilderHouse(Builder):
+# Concrete Buildings
+classHouse(Building):
 
 defbuild_floor(self):
-self.building.floor='One'
+self.floor='One'
 
 defbuild_size(self):
-self.building.size='Big'
+self.size='Big'
 
 
-classBuilderFlat(Builder):
+classFlat(Building):
 
 defbuild_floor(self):
-self.building.floor='More than One'
+self.floor='More than One'
 
 defbuild_size(self):
-self.building.size='Small'
+self.size='Small'
 
 
-# Product
-classBuilding(object):
+# In some very complex cases, it might be desirable to pull out the building
+# logic into another function (or a method on another class), rather than being
+# in the base class '__init__'. (This leaves you in the strange situation where
+# a concrete class does not have a useful constructor)
 
-def__init__(self):
-self.floor=None
-self.size=None
 
+classComplexBuilding(object):
 def__repr__(self):
 return'Floor:{0.floor} | Size:{0.size}'.format(self)
 
 
+classComplexHouse(ComplexBuilding):
+defbuild_floor(self):
+self.floor='One'
+
+defbuild_size(self):
+self.size='Big and fancy'
+
+
+defconstruct_building(cls):
+building=cls()
+building.build_floor()
+building.build_size()
+returnbuilding
+
+
 # Client
 if__name__=="__main__":
-building=construct_building(BuilderHouse())
-print(building)
-building=construct_building(BuilderFlat())
-print(building)
+house=House()
+print(house)
+flat=Flat()
+print(flat)
+
+# Using an external constructor function:
+complex_house=construct_building(ComplexHouse)
+print(complex_house)
 
 ### OUTPUT ###
 # Floor: One | Size: Big
 # Floor: More than One | Size: Small
+# Floor: One | Size: Big and fancy