Use prefix underscore for state variables and no underscore for parameters

contracts/crowdsale/price/IncreasingPriceCrowdsale.sol

@@ -49,8 +49,8 @@ contract IncreasingPriceCrowdsale is TimedCrowdsale {
    */
   function getCurrentRate() public view returns (uint256) {
     // solium-disable-next-line security/no-block-members
-    uint256 elapsedTime = block.timestamp.sub(openingTime);
-    uint256 timeRange = closingTime.sub(openingTime);
+    uint256 elapsedTime = block.timestamp.sub(openingTime());
+    uint256 timeRange = closingTime.sub(openingTime());
     uint256 rateRange = _initialRate.sub(_finalRate);
     return _initialRate.sub(elapsedTime.mul(rateRange).div(timeRange));
   }

contracts/crowdsale/validation/CappedCrowdsale.sol

@@ -11,45 +11,45 @@ import "../Crowdsale.sol";
 contract CappedCrowdsale is Crowdsale {
   using SafeMath for uint256;
 
-  uint256 private cap_;
+  uint256 private _cap;
 
   /**
    * @dev Constructor, takes maximum amount of wei accepted in the crowdsale.
-   * @param _cap Max amount of wei to be contributed
+   * @param cap Max amount of wei to be contributed
    */
-  constructor(uint256 _cap) public {
-    require(_cap > 0);
-    cap_ = _cap;
+  constructor(uint256 cap) public {
+    require(cap > 0);
+    _cap = cap;
   }
 
   /**
    * @return the cap of the crowdsale.
    */
   function cap() public view returns(uint256) {
-    return cap_;
+    return _cap;
   }
 
   /**
    * @dev Checks whether the cap has been reached.
    * @return Whether the cap was reached
    */
   function capReached() public view returns (bool) {
-    return weiRaised() >= cap_;
+    return weiRaised() >= _cap;
   }
 
   /**
    * @dev Extend parent behavior requiring purchase to respect the funding cap.
-   * @param _beneficiary Token purchaser
-   * @param _weiAmount Amount of wei contributed
+   * @param beneficiary Token purchaser
+   * @param weiAmount Amount of wei contributed
    */
   function _preValidatePurchase(
-    address _beneficiary,
-    uint256 _weiAmount
+    address beneficiary,
+    uint256 weiAmount
   )
     internal
   {
-    super._preValidatePurchase(_beneficiary, _weiAmount);
-    require(weiRaised().add(_weiAmount) <= cap_);
+    super._preValidatePurchase(beneficiary, weiAmount);
+    require(weiRaised().add(weiAmount) <= _cap);
   }
 
 }

contracts/crowdsale/validation/TimedCrowdsale.sol

@@ -11,15 +11,15 @@ import "../Crowdsale.sol";
 contract TimedCrowdsale is Crowdsale {
   using SafeMath for uint256;
 
-  uint256 public openingTime;
-  uint256 public closingTime;
+  uint256 private openingTime_;
+  uint256 private closingTime_;
 
   /**
    * @dev Reverts if not in crowdsale time range.
    */
   modifier onlyWhileOpen {
     // solium-disable-next-line security/no-block-members
-    require(block.timestamp >= openingTime && block.timestamp <= closingTime);
+    require(isOpen());
     _;
   }
 
@@ -33,8 +33,30 @@ contract TimedCrowdsale is Crowdsale {
     require(_openingTime >= block.timestamp);
     require(_closingTime >= _openingTime);
 
-    openingTime = _openingTime;
-    closingTime = _closingTime;
+    openingTime_ = _openingTime;
+    closingTime_ = _closingTime;
+  }
+
+  /**
+   * @return the crowdsale opening time.
+   */
+  function openingTime() public view returns(uint256) {
+    return openingTime_;
+  }
+
+  /**
+   * @return the crowdsale closing time.
+   */
+  function closingTime() public view returns(uint256) {
+    return closingTime_;
+  }
+
+  /**
+   * @return true if the crowdsale is open, false otherwise.
+   */
+  function isOpen() public view returns (bool) {
+    // solium-disable-next-line security/no-block-members
+    return block.timestamp >= openingTime_ && block.timestamp <= closingTime_;
   }
 
   /**
@@ -43,7 +65,7 @@ contract TimedCrowdsale is Crowdsale {
    */
   function hasClosed() public view returns (bool) {
     // solium-disable-next-line security/no-block-members
-    return block.timestamp > closingTime;
+    return block.timestamp > closingTime_;
   }
 
   /**

contracts/ownership/Ownable.sol

@@ -36,10 +36,17 @@ contract Ownable {
    * @dev Throws if called by any account other than the owner.
    */
   modifier onlyOwner() {
-    require(msg.sender == owner_);
+    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.

contracts/token/ERC20/ERC20Mintable.sol

@@ -16,13 +16,13 @@ contract ERC20Mintable is ERC20, Ownable {
   bool private mintingFinished_ = false;
 
 
-  modifier canMint() {
+  modifier onlyBeforeMintingFinished() {
     require(!mintingFinished_);
     _;
   }
 
-  modifier hasMintPermission() {
-    require(msg.sender == owner());
+  modifier onlyMinter() {
+    require(isOwner());
     _;
   }
 
@@ -44,8 +44,8 @@ contract ERC20Mintable is ERC20, Ownable {
     uint256 _amount
   )
     public
-    hasMintPermission
-    canMint
+    onlyMinter
+    onlyBeforeMintingFinished
     returns (bool)
   {
     _mint(_to, _amount);
@@ -57,7 +57,12 @@ contract ERC20Mintable is ERC20, Ownable {
    * @dev Function to stop minting new tokens.
    * @return True if the operation was successful.
    */
-  function finishMinting() public onlyOwner canMint returns (bool) {
+  function finishMinting()
+    public
+    onlyOwner
+    onlyBeforeMintingFinished
+    returns (bool)
+  {
     mintingFinished_ = true;
     emit MintFinished();
     return true;

contracts/token/ERC20/RBACMintableToken.sol

@@ -18,7 +18,7 @@ contract RBACMintableToken is ERC20Mintable, RBAC {
   /**
    * @dev override the Mintable token modifier to add role based logic
    */
-  modifier hasMintPermission() {
+  modifier onlyMinter() {
     checkRole(msg.sender, ROLE_MINTER);
     _;
   }

test/crowdsale/TimedCrowdsale.test.js

@@ -52,17 +52,20 @@ contract('TimedCrowdsale', function ([_, investor, wallet, purchaser]) {
     it('should be ended only after end', async function () {
       (await this.crowdsale.hasClosed()).should.equal(false);
       await increaseTimeTo(this.afterClosingTime);
+      (await this.crowdsale.isOpen()).should.equal(false);
       (await this.crowdsale.hasClosed()).should.equal(true);
     });
 
     describe('accepting payments', function () {
       it('should reject payments before start', async function () {
+        (await this.crowdsale.isOpen()).should.equal(false);
         await expectThrow(this.crowdsale.send(value), EVMRevert);
         await expectThrow(this.crowdsale.buyTokens(investor, { from: purchaser, value: value }), EVMRevert);
       });
 
       it('should accept payments after start', async function () {
         await increaseTimeTo(this.openingTime);
+        (await this.crowdsale.isOpen()).should.equal(true);
         await this.crowdsale.send(value);
         await this.crowdsale.buyTokens(investor, { value: value, from: purchaser });
       });

test/ownership/Ownable.behavior.js

@@ -13,8 +13,11 @@ function shouldBehaveLikeOwnable (owner, [anyone]) {
     });
 
     it('changes owner after transfer', async function () {
+      (await this.ownable.isOwner({ from: anyone })).should.be.equal(false);
       await this.ownable.transferOwnership(anyone, { from: owner });
+
       (await this.ownable.owner()).should.equal(anyone);
+      (await this.ownable.isOwner({ from: anyone })).should.be.equal(true);
     });
 
     it('should prevent non-owners from transfering', async function () {