Just Use Prettier™

Author: mjackson

modules/Broadcast.js

@@ -1,31 +1,31 @@
-import React from "react"
-import PropTypes from "prop-types"
-import invariant from "invariant"
+import React from "react";
+import PropTypes from "prop-types";
+import invariant from "invariant";
 
 function createBroadcast(initialValue) {
-  let currentValue = initialValue
-  let subscribers = []
+  let currentValue = initialValue;
+  let subscribers = [];
 
-  const getValue = () => currentValue
+  const getValue = () => currentValue;
 
   const publish = state => {
-    currentValue = state
-    subscribers.forEach(s => s(currentValue))
-  }
+    currentValue = state;
+    subscribers.forEach(s => s(currentValue));
+  };
 
   const subscribe = subscriber => {
-    subscribers.push(subscriber)
+    subscribers.push(subscriber);
 
     return () => {
-      subscribers = subscribers.filter(s => s !== subscriber)
-    }
-  }
+      subscribers = subscribers.filter(s => s !== subscriber);
+    };
+  };
 
   return {
     getValue,
     publish,
     subscribe
-  }
+  };
 }
 
 /**
@@ -43,42 +43,45 @@ class Broadcast extends React.Component {
     children: PropTypes.node.isRequired,
     compareValues: PropTypes.func,
     value: PropTypes.any
-  }
+  };
 
   static defaultProps = {
     compareValues: (prevValue, nextValue) => prevValue === nextValue
-  }
+  };
 
   static contextTypes = {
     broadcasts: PropTypes.object
-  }
+  };
 
   static childContextTypes = {
     broadcasts: PropTypes.object.isRequired
-  }
+  };
 
-  broadcast = createBroadcast(this.props.value)
+  broadcast = createBroadcast(this.props.value);
 
   getChildContext() {
     return {
       broadcasts: {
         ...this.context.broadcasts,
         [this.props.channel]: this.broadcast
       }
-    }
+    };
   }
 
   componentWillReceiveProps(nextProps) {
-    invariant(this.props.channel === nextProps.channel, "You cannot change <Broadcast channel>")
+    invariant(
+      this.props.channel === nextProps.channel,
+      "You cannot change <Broadcast channel>"
+    );
 
     if (!this.props.compareValues(this.props.value, nextProps.value)) {
-      this.broadcast.publish(nextProps.value)
+      this.broadcast.publish(nextProps.value);
     }
   }
 
   render() {
-    return React.Children.only(this.props.children)
+    return React.Children.only(this.props.children);
   }
 }
 
-export default Broadcast
+export default Broadcast;

modules/Subscriber.js

@@ -1,6 +1,6 @@
-import React from "react"
-import PropTypes from "prop-types"
-import invariant from "invariant"
+import React from "react";
+import PropTypes from "prop-types";
+import invariant from "invariant";
 
 /**
  * A <Subscriber> pulls the value for a channel off of context.broadcasts
@@ -11,62 +11,62 @@ class Subscriber extends React.Component {
     channel: PropTypes.string.isRequired,
     children: PropTypes.func,
     quiet: PropTypes.bool
-  }
+  };
 
   static defaultProps = {
     quiet: false
-  }
+  };
 
   static contextTypes = {
     broadcasts: PropTypes.object
-  }
+  };
 
   state = {
     value: undefined
-  }
+  };
 
   getBroadcast() {
-    const broadcasts = this.context.broadcasts || {}
-    const broadcast = broadcasts[this.props.channel]
+    const broadcasts = this.context.broadcasts || {};
+    const broadcast = broadcasts[this.props.channel];
 
     invariant(
       this.props.quiet || broadcast,
       '<Subscriber channel="%s"> must be rendered in the context of a <Broadcast channel="%s">',
       this.props.channel,
       this.props.channel
-    )
+    );
 
-    return broadcast
+    return broadcast;
   }
 
   componentWillMount() {
-    const broadcast = this.getBroadcast()
+    const broadcast = this.getBroadcast();
 
     if (broadcast) {
       this.setState({
         value: broadcast.getValue()
-      })
+      });
     }
   }
 
   componentDidMount() {
-    const broadcast = this.getBroadcast()
+    const broadcast = this.getBroadcast();
 
     if (broadcast) {
       this.unsubscribe = broadcast.subscribe(value => {
-        this.setState({ value })
-      })
+        this.setState({ value });
+      });
     }
   }
 
   componentWillUnmount() {
-    if (this.unsubscribe) this.unsubscribe()
+    if (this.unsubscribe) this.unsubscribe();
   }
 
   render() {
-    const { children } = this.props
-    return children ? children(this.state.value) : null
+    const { children } = this.props;
+    return children ? children(this.state.value) : null;
   }
 }
 
-export default Subscriber
+export default Subscriber;

modules/__tests__/Subscriber-test.js

@@ -1,19 +1,21 @@
-import React from "react"
-import ReactDOMServer from "react-dom/server"
-import Subscriber from "../Subscriber"
+import React from "react";
+import ReactDOMServer from "react-dom/server";
+import Subscriber from "../Subscriber";
 
 describe("A <Subscriber>", () => {
   it("throws an invariant when it is not rendered in the context of a <Broadcast>", () => {
     expect(() => {
-      ReactDOMServer.renderToStaticMarkup(<Subscriber channel="cupcakes" />)
-    }).toThrow()
-  })
+      ReactDOMServer.renderToStaticMarkup(<Subscriber channel="cupcakes" />);
+    }).toThrow();
+  });
 
   describe("with quiet=true", () => {
     it("does not throw when it is not rendered in the context of a <Broadcast>", () => {
       expect(() => {
-        ReactDOMServer.renderToStaticMarkup(<Subscriber quiet channel="cupcakes" />)
-      }).not.toThrow()
-    })
-  })
-})
+        ReactDOMServer.renderToStaticMarkup(
+          <Subscriber quiet channel="cupcakes" />
+        );
+      }).not.toThrow();
+    });
+  });
+});

modules/__tests__/integration-test.js

@@ -1,69 +1,75 @@
-import React from "react"
-import ReactDOM from "react-dom"
-import { EventEmitter } from "events"
-import { Broadcast, Subscriber } from "../index"
+import React from "react";
+import ReactDOM from "react-dom";
+import { EventEmitter } from "events";
+import { Broadcast, Subscriber } from "../index";
 
 it("works", done => {
-  const steps = []
-  const execNextStep = () => steps.shift()()
-  const div = document.createElement("div")
+  const steps = [];
+  const execNextStep = () => steps.shift()();
+  const div = document.createElement("div");
 
   // so we can trigger rerenders in ComponentWithStateForDescendants
-  const emitter = new EventEmitter()
+  const emitter = new EventEmitter();
 
   // A component has some state it wants to make available to descendants
   // 1. We create our Broadcast and Subscriber components
   const CheeseBroadcast = ({ cheese, children }) => (
     <Broadcast channel="cheese" value={cheese} children={children} />
-  )
+  );
 
-  const CheeseSubscriber = ({ children }) => <Subscriber channel="cheese" children={children} />
+  const CheeseSubscriber = ({ children }) => (
+    <Subscriber channel="cheese" children={children} />
+  );
 
   class ComponentWithStateForDescendants extends React.Component {
     constructor() {
-      super()
-      this.state = { cheese: "cheddar" }
+      super();
+      this.state = { cheese: "cheddar" };
       emitter.on("CHEESE", cheese => {
-        this.setState({ cheese })
-      })
+        this.setState({ cheese });
+      });
     }
 
-    componentDidMount = execNextStep
+    componentDidMount = execNextStep;
 
-    componentDidUpdate = execNextStep
+    componentDidUpdate = execNextStep;
 
     render() {
       // 2. render the Broadcast in the component w/ state and pass
       //    it the value we want accessible through context as a prop
       //    by the same name as when the Broadcast was created
-      return <CheeseBroadcast cheese={this.state.cheese}>{this.props.children}</CheeseBroadcast>
+      return (
+        <CheeseBroadcast cheese={this.state.cheese}>
+          {this.props.children}
+        </CheeseBroadcast>
+      );
     }
   }
 
-  let actualCheese = null
+  let actualCheese = null;
 
   steps.push(
     () => {
-      expect(actualCheese).toBe("cheddar")
-      emitter.emit("CHEESE", "gouda")
+      expect(actualCheese).toBe("cheddar");
+      emitter.emit("CHEESE", "gouda");
     },
     () => {
-      expect(actualCheese).toBe("gouda")
-      done()
+      expect(actualCheese).toBe("gouda");
+      done();
     }
-  )
+  );
 
   // 3. Render a <Subscriber> that calls back when the Broadcast
   //    gets a new value in its prop
   ReactDOM.render(
     <ComponentWithStateForDescendants>
       <CheeseSubscriber>
         {cheese => {
-          actualCheese = cheese
-          return null
+          actualCheese = cheese;
+          return null;
         }}
       </CheeseSubscriber>
     </ComponentWithStateForDescendants>,
     div
-  )
-})
+  );
+});

modules/index.js

@@ -1,2 +1,2 @@
-export Broadcast from "./Broadcast"
-export Subscriber from "./Subscriber"
+export Broadcast from "./Broadcast";
+export Subscriber from "./Subscriber";

package.json

@@ -70,9 +70,5 @@
     "subscriber",
     "subscription",
     "subscriptions"
-  ],
-  "prettier": {
-    "printWidth": 100,
-    "semi": false
-  }
+  ]
 }