Preserve empty lines (#44)

* Preserve empty lines at the source and contract level

* Remove wrong empty lines from snapshots

* Better handling of empty lines

* Fix linter errors

* Preserve empty lines in code blocks

* Use destructuring to extract helpers from prettier

* Use length instead of counter

* Run prettier

Author: Franco Victorio

src/printer.js

@@ -1,19 +1,39 @@
+const prettier = require('prettier');
+
 const {
-  concat,
-  group,
-  hardline,
-  indent,
-  join,
-  line,
-  softline
-} = require('prettier').doc.builders;
+  doc: {
+    builders: { concat, group, hardline, indent, join, line, softline }
+  },
+  util: { isNextLineEmptyAfterIndex }
+} = prettier;
+
+function printPreservingEmptyLines(path, key, options, print) {
+  const parts = [];
+  path.each(childPath => {
+    if (parts.length !== 0) {
+      parts.push(hardline);
+    }
+
+    parts.push(print(childPath));
+    if (
+      isNextLineEmptyAfterIndex(
+        options.originalText,
+        options.locEnd(childPath.getValue()) + 1
+      )
+    ) {
+      parts.push(hardline);
+    }
+  }, key);
+
+  return concat(parts);
+}
 
 function genericPrint(path, options, print) {
   const node = path.getValue();
   let doc;
   switch (node.type) {
     case 'SourceUnit':
-      return join(hardline, path.map(print, 'children'));
+      return printPreservingEmptyLines(path, 'children', options, print);
     case 'PragmaDirective':
       return concat(['pragma ', node.name, ' ', node.value, ';']);
     case 'ImportDirective':
@@ -44,11 +64,10 @@ function genericPrint(path, options, print) {
         ]);
       }
       return concat([
-        line,
         doc,
         ' {',
         indent(line),
-        indent(join(hardline, path.map(print, 'subNodes'))),
+        indent(printPreservingEmptyLines(path, 'subNodes', options, print)),
         line,
         '}',
         line
@@ -97,7 +116,7 @@ function genericPrint(path, options, print) {
         ]);
       }
       if (node.body) {
-        return concat([line, join(' ', [doc, path.call(print, 'body')])]);
+        return concat([join(' ', [doc, path.call(print, 'body')])]);
       }
       return concat([doc, ';']);
     case 'ParameterList':
@@ -128,7 +147,7 @@ function genericPrint(path, options, print) {
       return concat([
         '{',
         indent(line),
-        indent(join(line, path.map(print, 'statements'))),
+        indent(printPreservingEmptyLines(path, 'statements', options, print)),
         line,
         '}'
       ]);

tests/BasicIterator/__snapshots__/jsfmt.spec.js.snap

@@ -50,7 +50,6 @@ contract BasicIterator {
 	This is a very simple demonstration of a while loops. Same as JS/c.
 */
 
-
 contract BasicIterator {
   address creator; // reserve one "address"-type spot
   uint8[10] integers; // reserve a chunk of storage for 10 8-bit unsigned integers in an array
@@ -74,11 +73,11 @@ contract BasicIterator {
     }
     return sum;
   }
+
   /**********
      Standard kill() function to recover funds 
      **********/
 
-
   function kill() {
     if (msg.sender == creator) {
       suicide(creator); // kills this contract and sends remaining funds back to creator

tests/Inbox/__snapshots__/jsfmt.spec.js.snap

@@ -36,7 +36,6 @@ lines.
 */
 
 pragma solidity ^0.4.23;
-
 contract Inbox {
   string public message;
 

tests/Ownable/__snapshots__/jsfmt.spec.js.snap

@@ -78,72 +78,74 @@ contract Ownable {
 }
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 pragma solidity ^0.4.24;
+
 /**
  * @title Ownable
  * @dev The Ownable contract has an owner address, and provides basic authorization control
  * functions, this simplifies the implementation of "user permissions".
  */
-
 contract Ownable {
   address private _owner;
+
   event OwnershipRenounced(address indexed previousOwner);
   event OwnershipTransferred(
     address indexed previousOwner,
     address indexed newOwner
   );
+
   /**
    * @dev The Ownable constructor sets the original \`owner\` of the contract to the sender
    * account.
    */
-
   constructor() public {
     _owner = msg.sender;
   }
+
   /**
    * @return the address of the owner.
    */
-
   function owner() public view returns(address) {
     return _owner;
   }
+
   /**
    * @dev Throws if called by any account other than the owner.
    */
   modifier onlyOwner() {
     require(isOwner());
     _;
   }
+
   /**
    * @return true if \`msg.sender\` is the owner of the contract.
    */
-
   function isOwner() public view returns(bool) {
     return msg.sender == _owner;
   }
+
   /**
    * @dev Allows the current owner to relinquish control of the contract.
    * @notice Renouncing to ownership will leave the contract without an owner.
    * It will not be possible to call the functions with the \`onlyOwner\`
    * modifier anymore.
    */
-
   function renounceOwnership() public onlyOwner {
     emit OwnershipRenounced(_owner);
     _owner = address(0);
   }
+
   /**
    * @dev Allows the current owner to transfer control of the contract to a newOwner.
    * @param newOwner The address to transfer ownership to.
    */
-
   function transferOwnership(address newOwner) public onlyOwner {
     _transferOwnership(newOwner);
   }
+
   /**
    * @dev Transfers control of the contract to a newOwner.
    * @param newOwner The address to transfer ownership to.
    */
-
   function _transferOwnership(address newOwner) internal {
     require(newOwner != address(0));
     emit OwnershipTransferred(_owner, newOwner);

tests/SimpleAuction/__snapshots__/jsfmt.spec.js.snap

@@ -133,16 +133,21 @@ contract SimpleAuction {
   // or time periods in seconds.
   address public beneficiary;
   uint public auctionEnd;
+
   // Current state of the auction.
   address public highestBidder;
   uint public highestBid;
+
   // Allowed withdrawals of previous bids
   mapping(address => uint) pendingReturns;
+
   // Set to true at the end, disallows any change
   bool ended;
+
   // Events that will be fired on changes.
   event HighestBidIncreased(address bidder, uint amount);
   event AuctionEnded(address winner, uint amount);
+
   // The following is a so-called natspec comment,
   // recognizable by the three slashes.
   // It will be shown when the user is asked to
@@ -151,16 +156,15 @@ contract SimpleAuction {
   /// Create a simple auction with \`_biddingTime\`
   /// seconds bidding time on behalf of the
   /// beneficiary address \`_beneficiary\`.
-
   constructor(uint _biddingTime, address _beneficiary) public {
     beneficiary = _beneficiary;
     auctionEnd = now + _biddingTime;
   }
+
   /// Bid on the auction with the value sent
   /// together with this transaction.
   /// The value will only be refunded if the
   /// auction is not won.
-
   function bid() public payable {
     // No arguments are necessary, all
     // information is already part of
@@ -171,9 +175,11 @@ contract SimpleAuction {
     // Revert the call if the bidding
     // period is over.
     require(now <= auctionEnd, "Auction already ended.");
+
     // If the bid is not higher, send the
     // money back.
     require(msg.value > highestBid, "There already is a higher bid.");
+
     if (highestBid != 0) {
       // Sending back the money by simply using
       // highestBidder.send(highestBid) is a security risk
@@ -186,15 +192,16 @@ contract SimpleAuction {
     highestBid = msg.value;
     emit HighestBidIncreased(msg.sender, msg.value);
   }
-  /// Withdraw a bid that was overbid.
 
+  /// Withdraw a bid that was overbid.
   function withdraw() public returns(bool) {
     uint amount = pendingReturns[msg.sender];
     if (amount > 0) {
       // It is important to set this to zero because the recipient
       // can call this function again as part of the receiving call
       // before \`send\` returns.
       pendingReturns[msg.sender] = 0;
+
       if (!msg.sender.send(amount)) {
         // No need to call throw here, just reset the amount owing
         pendingReturns[msg.sender] = amount;
@@ -203,9 +210,9 @@ contract SimpleAuction {
     }
     return true;
   }
+
   /// End the auction and send the highest bid
   /// to the beneficiary.
-
   function auctionEnd() public {
     // It is a good guideline to structure functions that interact
     // with other contracts (i.e. they call functions or send Ether)
@@ -223,9 +230,11 @@ contract SimpleAuction {
     // 1. Conditions
     require(now >= auctionEnd, "Auction not yet ended.");
     require(!ended, "auctionEnd has already been called.");
+
     // 2. Effects
     ended = true;
     emit AuctionEnded(highestBidder, highestBid);
+
     // 3. Interaction
     beneficiary.transfer(highestBid);
   }