Updated code style to 4 space indentation and 120 characters per line. (#1508)

* Updated code style to 4 spaces and 120 max characters per line.

* Update contracts/token/ERC721/ERC721Pausable.sol

Co-Authored-By: nventuro <nicolas.venturo@gmail.com>

* Update contracts/token/ERC721/IERC721.sol

Co-Authored-By: nventuro <nicolas.venturo@gmail.com>

contracts/utils/Address.sol

@@ -4,25 +4,23 @@ pragma solidity ^0.4.24;
  * Utility library of inline functions on addresses
  */
 library Address {
-
-  /**
-   * Returns whether the target address is a contract
-   * @dev This function will return false if invoked during the constructor of a contract,
-   * as the code is not actually created until after the constructor finishes.
-   * @param account address of the account to check
-   * @return whether the target address is a contract
-   */
-  function isContract(address account) internal view returns (bool) {
-    uint256 size;
-    // XXX Currently there is no better way to check if there is a contract in an address
-    // than to check the size of the code at that address.
-    // See https://ethereum.stackexchange.com/a/14016/36603
-    // for more details about how this works.
-    // TODO Check this again before the Serenity release, because all addresses will be
-    // contracts then.
-    // solium-disable-next-line security/no-inline-assembly
-    assembly { size := extcodesize(account) }
-    return size > 0;
-  }
-
+    /**
+     * Returns whether the target address is a contract
+     * @dev This function will return false if invoked during the constructor of a contract,
+     * as the code is not actually created until after the constructor finishes.
+     * @param account address of the account to check
+     * @return whether the target address is a contract
+     */
+    function isContract(address account) internal view returns (bool) {
+        uint256 size;
+        // XXX Currently there is no better way to check if there is a contract in an address
+        // than to check the size of the code at that address.
+        // See https://ethereum.stackexchange.com/a/14016/36603
+        // for more details about how this works.
+        // TODO Check this again before the Serenity release, because all addresses will be
+        // contracts then.
+        // solium-disable-next-line security/no-inline-assembly
+        assembly { size := extcodesize(account) }
+        return size > 0;
+    }
 }

contracts/utils/Arrays.sol

@@ -8,49 +8,41 @@ import "../math/Math.sol";
  * @dev Utility library of inline array functions
  */
 library Arrays {
+    /**
+     * @dev Upper bound search function which is kind of binary search algoritm. It searches sorted
+     * array to find index of the element value. If element is found then returns it's index otherwise
+     * it returns index of first element which is grater than searched value. If searched element is
+     * bigger than any array element function then returns first index after last element (i.e. all
+     * values inside the array are smaller than the target). Complexity O(log n).
+     * @param array The array sorted in ascending order.
+     * @param element The element's value to be find.
+     * @return The calculated index value. Returns 0 for empty array.
+     */
+    function findUpperBound(uint256[] storage array, uint256 element) internal view returns (uint256) {
+        if (array.length == 0) {
+            return 0;
+        }
 
-  /**
-   * @dev Upper bound search function which is kind of binary search algoritm. It searches sorted
-   * array to find index of the element value. If element is found then returns it's index otherwise
-   * it returns index of first element which is grater than searched value. If searched element is
-   * bigger than any array element function then returns first index after last element (i.e. all
-   * values inside the array are smaller than the target). Complexity O(log n).
-   * @param array The array sorted in ascending order.
-   * @param element The element's value to be find.
-   * @return The calculated index value. Returns 0 for empty array.
-   */
-  function findUpperBound(
-    uint256[] storage array,
-    uint256 element
-  ) 
-    internal
-    view
-    returns (uint256)
-  {
-    if (array.length == 0) {
-      return 0;
+        uint256 low = 0;
+        uint256 high = array.length;
+
+        while (low < high) {
+            uint256 mid = Math.average(low, high);
+
+            // Note that mid will always be strictly less than high (i.e. it will be a valid array index)
+            // because Math.average rounds down (it does integer division with truncation).
+            if (array[mid] > element) {
+                high = mid;
+            } else {
+                low = mid + 1;
+            }
+        }
+
+        // At this point `low` is the exclusive upper bound. We will return the inclusive upper bound.
+        if (low > 0 && array[low - 1] == element) {
+            return low - 1;
+        } else {
+            return low;
+        }
     }
-    
-    uint256 low = 0;
-    uint256 high = array.length;
-
-    while (low < high) {
-      uint256 mid = Math.average(low, high);
-
-      // Note that mid will always be strictly less than high (i.e. it will be a valid array index) 
-      // because Math.average rounds down (it does integer division with truncation).
-      if (array[mid] > element) {
-        high = mid;
-      } else {
-        low = mid + 1;
-      }
-    }
-
-    // At this point `low` is the exclusive upper bound. We will return the inclusive upper bound.
-    if (low > 0 && array[low - 1] == element) {
-      return low - 1;
-    } else {
-      return low;
-    }
-  }
 }

contracts/utils/ReentrancyGuard.sol

@@ -7,28 +7,26 @@ pragma solidity ^0.4.24;
  * mark it `external`.
  */
 contract ReentrancyGuard {
+    /// @dev counter to allow mutex lock with only one SSTORE operation
+    uint256 private _guardCounter;
 
-  /// @dev counter to allow mutex lock with only one SSTORE operation
-  uint256 private _guardCounter;
-
-  constructor() internal {
-    // The counter starts at one to prevent changing it from zero to a non-zero
-    // value, which is a more expensive operation.
-    _guardCounter = 1;
-  }
-
-  /**
-   * @dev Prevents a contract from calling itself, directly or indirectly.
-   * Calling a `nonReentrant` function from another `nonReentrant`
-   * function is not supported. It is possible to prevent this from happening
-   * by making the `nonReentrant` function external, and make it call a
-   * `private` function that does the actual work.
-   */
-  modifier nonReentrant() {
-    _guardCounter += 1;
-    uint256 localCounter = _guardCounter;
-    _;
-    require(localCounter == _guardCounter);
-  }
+    constructor () internal {
+        // The counter starts at one to prevent changing it from zero to a non-zero
+        // value, which is a more expensive operation.
+        _guardCounter = 1;
+    }
 
+    /**
+     * @dev Prevents a contract from calling itself, directly or indirectly.
+     * Calling a `nonReentrant` function from another `nonReentrant`
+     * function is not supported. It is possible to prevent this from happening
+     * by making the `nonReentrant` function external, and make it call a
+     * `private` function that does the actual work.
+     */
+    modifier nonReentrant() {
+        _guardCounter += 1;
+        uint256 localCounter = _guardCounter;
+        _;
+        require(localCounter == _guardCounter);
+    }
 }