Introduce PropTypes.shape

This diff introduces PropType.shape which lets you type an object. PropType.object was already defined and since it isn't a function I couldn't really overload the meaning to also accept a type list. Instead of doing hackery, I decided to name it `shape`.

An example where this could be used is style:

```
  propTypes: {
    style: PropTypes.shape({
      color: PropStyle.string,
      fontSize: PropTypes.number
    })
  }
```

src/core/ReactPropTypes.js

@@ -81,6 +81,7 @@ var Props = {
   object: createPrimitiveTypeChecker('object'),
   string: createPrimitiveTypeChecker('string'),
 
+  shape: createShapeTypeChecker,
   oneOf: createEnumTypeChecker,
   oneOfType: createUnionTypeChecker,
 
@@ -128,14 +129,20 @@ function isRenderable(propValue) {
   }
 }
 
+// Equivalent of typeof but with special handling for arrays
+function getPropType(propValue) {
+  var propType = typeof propValue;
+  if (propType === 'object' && Array.isArray(propValue)) {
+    return 'array';
+  }
+  return propType;
+}
+
 function createPrimitiveTypeChecker(expectedType) {
   function validatePrimitiveType(
     shouldThrow, propValue, propName, componentName, location
   ) {
-    var propType = typeof propValue;
-    if (propType === 'object' && Array.isArray(propValue)) {
-      propType = 'array';
-    }
+    var propType = getPropType(propValue);
     var isValid = propType === expectedType;
     if (!shouldThrow) {
       return isValid;
@@ -174,6 +181,36 @@ function createEnumTypeChecker(expectedValues) {
   return createChainableTypeChecker(validateEnumType);
 }
 
+function createShapeTypeChecker(shapeTypes) {
+  function validateShapeType(
+    shouldThrow, propValue, propName, componentName, location
+  ) {
+    var propType = getPropType(propValue);
+    var isValid = propType === 'object';
+    if (isValid) {
+      for (var key in shapeTypes) {
+        var checker = shapeTypes[key];
+        if (checker) {
+          // It's going to throw an exception if it doesn't pass
+          checker(propValue, key, componentName, location);
+        }
+      }
+    }
+    if (!shouldThrow) {
+      return isValid;
+    }
+    invariant(
+      isValid,
+      'Invalid %s `%s` of type `%s` supplied to `%s`, expected `object`.',
+      ReactPropTypeLocationNames[location],
+      propName,
+      propType,
+      componentName
+    );
+  }
+  return createChainableTypeChecker(validateShapeType);
+}
+
 function createInstanceTypeChecker(expectedClass) {
   function validateInstanceType(
     shouldThrow, propValue, propName, componentName, location

src/core/__tests__/ReactPropTypes-test.js

@@ -141,6 +141,69 @@ describe('Enum Types', function() {
   });
 });
 
+describe('Shape Types', function() {
+  beforeEach(function() {
+    require('mock-modules').dumpCache();
+  });
+
+  it("should throw for non objects", function() {
+    expect(typeCheck(Props.shape({}), 'some string')).toThrow(
+      'Invariant Violation: Invalid prop `testProp` of type `string` ' +
+      'supplied to `testComponent`, expected `object`.'
+    );
+    expect(typeCheck(Props.shape({}), ['array'])).toThrow(
+      'Invariant Violation: Invalid prop `testProp` of type `array` ' +
+      'supplied to `testComponent`, expected `object`.'
+    );
+  });
+
+  it("should not throw for empty values", function() {
+    expect(typeCheck(Props.shape({}), undefined)).not.toThrow();
+    expect(typeCheck(Props.shape({}), null)).not.toThrow();
+    expect(typeCheck(Props.shape({}), {})).not.toThrow();
+  });
+
+  it("should throw for empty required value", function() {
+    expect(typeCheck(Props.shape({}).isRequired, undefined)).toThrow(
+      'Invariant Violation: Required prop `testProp` was not specified in ' +
+      '`testComponent`.'
+    );
+    expect(typeCheck(Props.shape({}).isRequired, null)).toThrow(
+      'Invariant Violation: Required prop `testProp` was not specified in ' +
+      '`testComponent`.'
+    );
+    expect(typeCheck(Props.shape({}).isRequired, {})).not.toThrow();
+  });
+
+  it("should not throw for non specified types", function() {
+    expect(typeCheck(Props.shape({}), {key: 1})).not.toThrow();
+  });
+
+  it("should not throw for valid types", function() {
+    expect(typeCheck(Props.shape({
+      key: Props.number
+    }), {key: 1})).not.toThrow();
+  });
+
+  it("should throw for required valid types", function() {
+    expect(typeCheck(Props.shape({
+      key: Props.number.isRequired
+    }), {})).toThrow(
+      'Invariant Violation: Required prop `key` was not specified in ' +
+      '`testComponent`.'
+    );
+  });
+
+  it("should throw for invalid key types", function() {
+    expect(typeCheck(Props.shape({
+      key: Props.number
+    }), {key: 'abc'})).toThrow(
+      'Invariant Violation: Invalid prop `key` of type `string` supplied to ' +
+      '`testComponent`, expected `number`.'
+    );
+  });
+});
+
 describe('Instance Types', function() {
   beforeEach(function() {
     require('mock-modules').dumpCache();