Update readmes

Author: scottt2

adapter/README.md

@@ -1,4 +1,40 @@
-# Adapter Pattern
+## Adapter Pattern
 An adapter allows two incompatible interfaces to work together. This is the real-world definition for an adapter. Interfaces may be incompatible, but the inner functionality should suit the need. The adapter design pattern allows otherwise incompatible classes to work together by converting the interface of one class into an interface expected by the clients.
 
 [Wikipedia: Adapter Pattern](https://en.wikipedia.org/wiki/Adapter_pattern)
+
+### Example
+
+[View on GitHub](https://github.com/scottt2/design-patterns-in-dart/tree/master/adapter)
+
+```dart
+const adapteeMessage = 'Adaptee#method was called';
+
+class Adaptee {
+  String method() {
+    print('Adaptee#method is being called');
+
+    return adapteeMessage;
+  }
+}
+
+abstract class Target {
+  String call();
+}
+
+class Adapter implements Target {
+  String call() {
+    var adaptee = Adaptee();
+    print('Adapter#call is being called');
+
+    return adaptee.method();
+  }
+}
+
+void main() {
+  var adapter = Adapter();
+  var result = adapter.call();
+
+  assert(result == adapteeMessage);
+}
+```

builder/README.md

@@ -1,4 +1,96 @@
-# Builder Pattern
+## Builder Pattern
 The intent of the Builder design pattern is to separate the construction of a complex object from its representation. By doing so the same construction process can create different representations.
 
 [Wikipedia: Builder Pattern](https://en.wikipedia.org/wiki/Builder_pattern)
+
+### Example
+
+[View on GitHub](https://github.com/scottt2/design-patterns-in-dart/tree/master/builder)
+
+```dart
+class PizzaBuilder {
+  String _crust;
+  int _diameter;
+  Set<String> _toppings;
+
+  PizzaBuilder(this._diameter);
+
+  String get crust => _crust;
+  set crust(String newCrust) {
+    _crust = newCrust;
+  }
+
+  int get diameter => _diameter;
+  set diameter(int newDiameter) {
+    _diameter = newDiameter;
+  }
+
+  Set<String> get toppings => _toppings;
+  set toppings(Set<String> newToppings) {
+    _toppings = newToppings;
+    _ensureCheese();
+  }
+ 
+  void _ensureCheese() {
+    _toppings.add("cheese");
+  }
+
+  Pizza build() {
+    return Pizza(this);
+  }
+}
+
+class Pizza {
+  String _crust;
+  int _diameter;
+  Set<String> _toppings;
+
+  Pizza(PizzaBuilder builder) {
+    _crust = builder.crust;
+    _diameter = builder.diameter;
+    _toppings = builder.toppings;
+  }
+
+  String get crust => _crust;
+  int get diameter => _diameter;
+  String get toppings => _stringifiedToppings();
+  String _stringifiedToppings() {
+    var stringToppings = _toppings.join(", ");
+    var lastComma = stringToppings.lastIndexOf(",");
+    var replacement = ",".allMatches(stringToppings).length > 1 ? ", and" : " and";
+
+    return stringToppings.replaceRange(lastComma, lastComma + 1, replacement);
+  }
+
+  @override
+  String toString() {
+    return "A delicous $_diameter\" pizza with $_crust crust covered in $toppings";
+  }
+}
+
+void main() {
+  // Create a handy PizzaBuilder with an 8" diameter.
+  var pizzaBuilder = PizzaBuilder(8);
+
+  // Add some attributes to the builder.
+  pizzaBuilder.crust = "deep dish";
+  pizzaBuilder.toppings = Set.from(["pepperoni"]);
+
+  // Let's make a pizza!
+  var plainPizza = Pizza(pizzaBuilder);
+  print("Behold! $plainPizza.");
+  assert(plainPizza.toString() == "Behold! A delicous 8\" pizza with deep dish crust covered in pepperoni and cheese.");
+
+  // Now to adjust some things for the next pizza...
+  pizzaBuilder.crust = "gold plated";
+  pizzaBuilder.diameter = 72;
+  pizzaBuilder.toppings = Set.from(["anchovies", "caviar", "diamonds"]);
+
+  // The beauty of the build is you can quickly iterate and produce instances of a class.
+  // For example, we have an early employee of the latest unicorn in line. So much disposable income!
+  // Also note, we use the .build() function of the builder this time.
+  var luxuriousPizza = pizzaBuilder.build();
+  print("Wow! $luxuriousPizza? Someone is rich!");
+  assert(luxuriousPizza.toString() == "Wow! A delicous 72\" pizza with gold plated crust covered in anchovies, caviar, diamonds, and cheese? Someone is rich!");
+}
+```

composite/README.md

@@ -1,5 +1,87 @@
-# Composite Pattern
+## Composite Pattern
 In software engineering, the composite pattern is a partitioning design pattern. The composite pattern describes a group of objects that is treated the same way as a single instance of the same type of object. The intent of a composite is to "compose" objects into tree structures to represent part-whole hierarchies. Implementing the composite pattern lets clients treat individual objects and compositions uniformly.
 
 [Wikipedia: Composite Pattern](https://en.wikipedia.org/wiki/Composite_pattern)
 
+### Example
+
+[View on GitHub](https://github.com/scottt2/design-patterns-in-dart/tree/master/composite)
+
+```dart
+abstract class Thing {
+  String name;
+  void doSomething();
+}
+
+class CompositeThing implements Thing {
+  String name;
+  Set<Thing> _childThings = Set();
+
+  CompositeThing(this.name);
+
+  void addChild(Thing child) {
+    _childThings.add(child);
+  }
+
+  void doSomething() {
+    print("\r\n** $name is doing something! ** \r\n");
+    _childThings.forEach((thing) => thing.doSomething());
+    print("\r\n** $name is all done. ** \r\n");
+  }
+}
+
+class LeafThing implements Thing {
+  String name;
+
+  LeafThing(this.name);
+
+  void doSomething() {
+    print("*  $name!");
+  }
+}
+
+void main() {
+  var compositeParent = CompositeThing("Cat in the Hat");
+  var compositeChild1 = CompositeThing("Thing 1");
+  var compositeChild2 = CompositeThing("Thing 2");
+
+  var leaf1_1 = LeafThing("Frustrate fish");
+  var leaf1_2 = LeafThing("Knock down vases");
+  var leaf2_1 = LeafThing("Ruin mom's dress");
+  var leaf2_2 = LeafThing("Clean up");
+
+  compositeChild1.addChild(leaf1_1);
+  compositeChild1.addChild(leaf1_2);
+  
+  compositeChild2.addChild(leaf2_1);
+  compositeChild2.addChild(leaf2_2);
+
+  compositeParent.addChild(compositeChild1);
+  compositeParent.addChild(compositeChild2);
+
+  compositeParent.doSomething();
+
+  /*
+   ** Cat in the Hat is doing something! **
+
+
+    ** Thing 1 is doing something! **
+
+    *  Frustrate fish!
+    *  Knock down vases!
+
+    ** Thing 1 is all done. **
+
+
+    ** Thing 2 is doing something! **
+
+    *  Ruin mom's dress!
+    *  Clean up!
+
+    ** Thing 2 is all done. **
+
+
+    ** Cat in the Hat is all done. **
+  */
+}
+```

factory_method/README.md

@@ -1,4 +1,66 @@
-# Factory Method Pattern
+## Factory Method Pattern
 The factory method pattern is a creational pattern that uses factory methods to deal with the problem of creating objects without having to specify the exact class of the object that will be created. This is done by creating objects by calling a factory method—either specified in an interface and implemented by child classes, or implemented in a base class and optionally overridden by derived classes—rather than by calling a constructor.
 
 [Wikipedia: Factory Method](https://en.wikipedia.org/wiki/Factory_method_pattern)
+
+### Example
+
+[View on GitHub](https://github.com/scottt2/design-patterns-in-dart/tree/master/factor_method)
+
+```dart
+class Volume {
+  final int quantity;
+  final String unit;
+
+  Volume(this.quantity, this.unit);
+  String toString() => "$quantity $unit";
+}
+
+abstract class Vessel {
+  Volume volume;
+  String liquid;
+}
+
+class Bucket extends Vessel {
+  final Volume volume;
+
+  Bucket(int q, String u) : volume = Volume(q, u);
+  String toString() => "a $volume bucket full of $liquid";
+}
+
+class Cup extends Vessel {
+ final Volume volume;
+
+  Cup(int q, String u) : volume = Volume(q, u);
+  String toString() => "a $volume cup full of $liquid";
+}
+
+enum Tiredness {
+  rested, sleepy, barelyAlive, hasChildren
+}
+
+class CoffeeVesselFactory {
+  static Vessel vesselFor(Tiredness howTired) {
+    Vessel vessel;
+    switch(howTired) {
+      case Tiredness.rested: vessel = Cup(100, "milliliter"); break;
+      case Tiredness.sleepy:
+      case Tiredness.barelyAlive: vessel = Cup(500, "milliliter"); break;
+      case Tiredness.hasChildren: vessel = Bucket(5, "liter"); break;
+      default: vessel = Cup(200, "milliliter"); break;
+    }
+    vessel.liquid = "coffee";
+    return vessel;
+  }
+}
+
+void main() {
+  var sleepyVessel = CoffeeVesselFactory.vesselFor(Tiredness.sleepy);
+  var kidVessel = CoffeeVesselFactory.vesselFor(Tiredness.hasChildren);
+
+  // A sleepy person would like a 500 milliliter cup full of coffee.
+  print("A sleepy person would like $sleepyVessel.");
+  // A person with children NEEDS a 5 liter bucket full of coffee.
+  print("A person with children NEEDS $kidVessel.");
+}
+```

proxy/README.md

@@ -1,4 +1,53 @@
-# Proxy Pattern
+## Proxy Pattern
 A proxy, in its most general form, is a class functioning as an interface to something else. The proxy could interface to anything: a network connection, a large object in memory, a file, or some other resource that is expensive or impossible to duplicate. In short, a proxy is a wrapper or agent object that is being called by the client to access the real serving object behind the scenes.
 
 [Wikipedia: Proxy Pattern](https://en.wikipedia.org/wiki/Proxy_pattern)
+
+### Example
+
+[View on GitHub](https://github.com/scottt2/design-patterns-in-dart/tree/master/proxy)
+
+```dart
+abstract class Subject {
+  void someMethod();
+}
+
+class ExpensiveClass implements Subject {
+  String name;
+
+  ExpensiveClass(this.name);
+
+  void someMethod() {
+    print("someMethod of $name (an ExpensiveClass) is being called");
+  }
+}
+
+class Proxy implements Subject {
+  String _name;
+  ExpensiveClass _sub;
+
+  Proxy(this._name);
+
+  void someMethod() {
+    print("someMethod of $_name (a Proxy) is being called");
+    _subject().someMethod();
+  }
+
+  ExpensiveClass _subject() {
+    if (_sub != null) return _sub;
+    print("Creating an instance of ExpensiveClass for the proxy...");
+    _sub = ExpensiveClass(_name);
+    return _sub;
+  }
+}
+
+void main() {
+  var proxy = Proxy("yay");
+  print("With our handy proxy, we call someMethod...\r\n");
+  proxy.someMethod();
+  print("\r\nNotice that the proxy did not have an instance of ExpensiveClass, so it made one when required.");
+  print("Now if we call someMethod again...\r\n");
+  proxy.someMethod();
+  print("\r\nWe reuse the instance we made above!");
+}
+```