update: run rubocop

Rakefile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # *******************************************************************************
 # OpenStudio(R), Copyright (c) 2008-2020, Alliance for Sustainable Energy, LLC.
 # All rights reserved.

lib/measures/AddOverhangsByProjectionFactor/tests/AddOverhangsByProjectionFactor_Test.rb

@@ -92,7 +92,7 @@ def test_AddOverhangsByProjectionFactor_good
     model = model.get
 
     model.getSpaces.each do |space|
-      if space.name.get =~ Regexp.new(/Space 104/)
+      if space.name.get.match?(Regexp.new(/Space 104/))
         # should be two space shading groups
         assert_equal(2, space.shadingSurfaceGroups.size)
       else

lib/measures/IncreaseInsulationRValueForExteriorWalls/tests/IncreaseInsulationRValueForExteriorWalls_01_Test.rb

@@ -208,7 +208,7 @@ def test_IncreaseInsulationRValueForExteriorWalls_NewConstruction_FullyCosted
     expected_messages["Construction 'Test_No Insulation' does not appear to have an insulation layer and was not altered."] = false
     result.warnings.each do |warning|
       expected_messages.each_key do |message|
-        if warning.logMessage =~ Regexp.new(message)
+        if warning.logMessage.match?(Regexp.new(message))
           assert(expected_messages[message] == false, "Message '#{message}' found multiple times")
           expected_messages[message] = true
         end

lib/measures/add_energy_recovery_ventilator/tests/AddEnergyRecoveryVentilator_Test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'openstudio'
 require 'openstudio/ruleset/ShowRunnerOutput'
 
@@ -6,55 +8,51 @@
 require 'test/unit'
 
 class AddEnergyRecoveryVentilator_Test < Test::Unit::TestCase
-
   # def setup
   # end
 
   # def teardown
   # end
-  
+
   def test_AddEnergyRecoveryVentilator
-
     # create an instance of the measure
     measure = AddEnergyRecoveryVentilator.new
-    
+
     # create an instance of a runner
     runner = OpenStudio::Ruleset::OSRunner.new
-    
+
     # make an empty model
     model = OpenStudio::Model::Model.new
-    
+
     # get arguments and test that they are what we are expecting
     arguments = measure.arguments(model)
     assert_equal(2, arguments.size)
-    assert_equal("user_name", arguments[0].name)
-    assert_equal("add_space", arguments[1].name)
-    assert((not arguments[0].hasDefaultValue))
+    assert_equal('user_name', arguments[0].name)
+    assert_equal('add_space', arguments[1].name)
+    assert(!arguments[0].hasDefaultValue)
 
     # set argument values to bad values and run the measure
     argument_map = OpenStudio::Ruleset::OSArgumentMap.new
     user_name = arguments[0].clone
-    assert(user_name.setValue(""))
-    argument_map["user_name"] = user_name
+    assert(user_name.setValue(''))
+    argument_map['user_name'] = user_name
     measure.run(model, runner, argument_map)
     result = runner.result
-    assert(result.value.valueName == "Fail")
-       
+    assert(result.value.valueName == 'Fail')
+
     # set argument values to good values and run the measure on model with spaces
     argument_map = OpenStudio::Ruleset::OSArgumentMap.new
     user_name = arguments[0].clone
-    assert(user_name.setValue("david"))
-    argument_map["user_name"] = user_name
+    assert(user_name.setValue('david'))
+    argument_map['user_name'] = user_name
     add_space = arguments[1].clone
     assert(add_space.setValue(true))
-    argument_map["add_space"] = add_space
+    argument_map['add_space'] = add_space
     measure.run(model, runner, argument_map)
     result = runner.result
     show_output(result)
-    assert(result.value.valueName == "Success")
+    assert(result.value.valueName == 'Success')
     assert(result.warnings.size == 1)
     assert(result.info.size == 2)
-
-  end  
-
+  end
 end

lib/measures/improve_simple_glazing_by_percentage/measure.rb

@@ -1,82 +1,80 @@
+# frozen_string_literal: true
+
 # see the URL below for information on how to write OpenStudio measures
 # http://nrel.github.io/OpenStudio-user-documentation/reference/measure_writing_guide/
 
 # start the measure
 class ImproveSimpleGlazingByPercentage < OpenStudio::Ruleset::ModelUserScript
-
   # human readable name
   def name
-    return "improve_simple_glazing_by_percentage"
+    return 'improve_simple_glazing_by_percentage'
   end
 
   # define the arguments that the user will input
   def arguments(model)
     args = OpenStudio::Ruleset::OSArgumentVector.new
 
     # make an argument for glazing u_value improvement percentage
-    u_value_improvement_percent = OpenStudio::Ruleset::OSArgument.makeDoubleArgument("u_value_improvement_percent", true)
-    u_value_improvement_percent.setDisplayName("U-value Improvement Percentage (%)")
-	u_value_improvement_percent.setDefaultValue(20)
+    u_value_improvement_percent = OpenStudio::Ruleset::OSArgument.makeDoubleArgument('u_value_improvement_percent', true)
+    u_value_improvement_percent.setDisplayName('U-value Improvement Percentage (%)')
+    u_value_improvement_percent.setDefaultValue(20)
     args << u_value_improvement_percent
-	
-	# make an argument for glazing shgc improvement percentage
-    shgc_improvement_percent = OpenStudio::Ruleset::OSArgument.makeDoubleArgument("shgc_improvement_percent", true)
-    shgc_improvement_percent.setDisplayName("SHGC improvement Percentage (%)")
-	shgc_improvement_percent.setDefaultValue(20)
+
+    # make an argument for glazing shgc improvement percentage
+    shgc_improvement_percent = OpenStudio::Ruleset::OSArgument.makeDoubleArgument('shgc_improvement_percent', true)
+    shgc_improvement_percent.setDisplayName('SHGC improvement Percentage (%)')
+    shgc_improvement_percent.setDefaultValue(20)
     args << shgc_improvement_percent
 
     return args
   end
 
   # define what happens when the measure is run
-  def run(model, runner, user_arguments)	
+  def run(model, runner, user_arguments)
     super(model, runner, user_arguments)
 
     # use the built-in error checking
     if !runner.validateUserArguments(arguments(model), user_arguments)
       return false
     end
 
-	#assign the user inputs to variables
-    u_value_improvement_percent = runner.getDoubleArgumentValue("u_value_improvement_percent",user_arguments)
-	shgc_improvement_percent = runner.getDoubleArgumentValue("shgc_improvement_percent",user_arguments)
-
-	# replace simple glazing window parameters
-	materials = model.getMaterials
-	materials.each do |material|
-	  if material.to_SimpleGlazing.is_initialized
-		material_type_glazingsimple = material.to_SimpleGlazing.get
-
-		# get the original value for reporting
-		u_value_old = nil
-		shgc_old = nil
-		u_value_old = material_type_glazingsimple.uFactor
-		shgc_old = material_type_glazingsimple.solarHeatGainCoefficient
-
-		# Update the values from user input
-		material_type_glazingsimple.setUFactor(material_type_glazingsimple.uFactor - material_type_glazingsimple.uFactor * u_value_improvement_percent * 0.01)
-		shgc_new = material_type_glazingsimple.setSolarHeatGainCoefficient(material_type_glazingsimple.solarHeatGainCoefficient - material_type_glazingsimple.solarHeatGainCoefficient * shgc_improvement_percent * 0.01)
-
-		# get the updated value for reporting
-		u_value_new = nil
-		shgc_new = nil
-		u_value_new = material_type_glazingsimple.uFactor
-		shgc_new = material_type_glazingsimple.solarHeatGainCoefficient
-
-		# report initial condition of model
-		runner.registerInitialCondition("The building started with #{u_value_old} U-value, #{shgc_old} SHGC.")
-
-		# report final condition of model
-		runner.registerFinalCondition("The building finished with #{u_value_new} U-value, #{shgc_new} SHGC.")
-
-	  end
-
-	end
+    # assign the user inputs to variables
+    u_value_improvement_percent = runner.getDoubleArgumentValue('u_value_improvement_percent', user_arguments)
+    shgc_improvement_percent = runner.getDoubleArgumentValue('shgc_improvement_percent', user_arguments)
 
-    return true
+    # replace simple glazing window parameters
+    materials = model.getMaterials
+    materials.each do |material|
+      if material.to_SimpleGlazing.is_initialized
+        material_type_glazingsimple = material.to_SimpleGlazing.get
+
+        # get the original value for reporting
+        u_value_old = nil
+        shgc_old = nil
+        u_value_old = material_type_glazingsimple.uFactor
+        shgc_old = material_type_glazingsimple.solarHeatGainCoefficient
+
+        # Update the values from user input
+        material_type_glazingsimple.setUFactor(material_type_glazingsimple.uFactor - material_type_glazingsimple.uFactor * u_value_improvement_percent * 0.01)
+        shgc_new = material_type_glazingsimple.setSolarHeatGainCoefficient(material_type_glazingsimple.solarHeatGainCoefficient - material_type_glazingsimple.solarHeatGainCoefficient * shgc_improvement_percent * 0.01)
 
+        # get the updated value for reporting
+        u_value_new = nil
+        shgc_new = nil
+        u_value_new = material_type_glazingsimple.uFactor
+        shgc_new = material_type_glazingsimple.solarHeatGainCoefficient
+
+        # report initial condition of model
+        runner.registerInitialCondition("The building started with #{u_value_old} U-value, #{shgc_old} SHGC.")
+
+        # report final condition of model
+        runner.registerFinalCondition("The building finished with #{u_value_new} U-value, #{shgc_new} SHGC.")
+
+      end
+    end
+
+    return true
   end
-
 end
 
 # register the measure to be used by the application

lib/measures/reduce_water_use_by_percentage/measure.rb

@@ -1,63 +1,60 @@
+# frozen_string_literal: true
+
 # see the URL below for information on how to write OpenStudio measures
 # http://nrel.github.io/OpenStudio-user-documentation/reference/measure_writing_guide/
 
 # start the measure
 class ReduceWaterUseByPercentage < OpenStudio::Ruleset::ModelUserScript
-
   # human readable name
   def name
-    return "reduce_water_use_by_percentage"
+    return 'reduce_water_use_by_percentage'
   end
 
   # define the arguments that the user will input
   def arguments(model)
     args = OpenStudio::Ruleset::OSArgumentVector.new
 
     # make an argument for water use reduction percentage
-    water_use_reduction_percent = OpenStudio::Ruleset::OSArgument.makeDoubleArgument("water_use_reduction_percent", true)
-    water_use_reduction_percent.setDisplayName("Water Use Reduction Percentage (%)")
-	water_use_reduction_percent.setDefaultValue(20)
+    water_use_reduction_percent = OpenStudio::Ruleset::OSArgument.makeDoubleArgument('water_use_reduction_percent', true)
+    water_use_reduction_percent.setDisplayName('Water Use Reduction Percentage (%)')
+    water_use_reduction_percent.setDefaultValue(20)
     args << water_use_reduction_percent
 
     return args
   end
 
   # define what happens when the measure is run
-  def run(model, runner, user_arguments)	
+  def run(model, runner, user_arguments)
     super(model, runner, user_arguments)
 
     # use the built-in error checking
     if !runner.validateUserArguments(arguments(model), user_arguments)
       return false
     end
 
-	#assign the user inputs to variables
-    water_use_reduction_percent = runner.getDoubleArgumentValue("water_use_reduction_percent",user_arguments)
+    # assign the user inputs to variables
+    water_use_reduction_percent = runner.getDoubleArgumentValue('water_use_reduction_percent', user_arguments)
+
+    # replace water use parameters
+    model.getWaterUseEquipments.each do |water_use_equipment|
+      # get the original value for reporting
+      peak_flow_rate_si_old = water_use_equipment.waterUseEquipmentDefinition.peakFlowRate # m^3/s
+
+      # Update the values from user input
+      water_use_equipment.waterUseEquipmentDefinition.setPeakFlowRate(water_use_equipment.waterUseEquipmentDefinition.peakFlowRate - water_use_equipment.waterUseEquipmentDefinition.peakFlowRate * water_use_reduction_percent * 0.01)
 
-	# replace water use parameters
-	model.getWaterUseEquipments.each do |water_use_equipment|
-
-	  # get the original value for reporting
-	  peak_flow_rate_si_old = water_use_equipment.waterUseEquipmentDefinition.peakFlowRate # m^3/s
-
-	  # Update the values from user input
-	  water_use_equipment.waterUseEquipmentDefinition.setPeakFlowRate(water_use_equipment.waterUseEquipmentDefinition.peakFlowRate - water_use_equipment.waterUseEquipmentDefinition.peakFlowRate * water_use_reduction_percent * 0.01)
-
-	  # get the updated value for reporting
-	  peak_flow_rate_si_new = water_use_equipment.waterUseEquipmentDefinition.peakFlowRate # m^3/s
-
-	  # report initial condition of model
-	  runner.registerInitialCondition("Peak flow rate is #{peak_flow_rate_si_old} m^3/s..")
+      # get the updated value for reporting
+      peak_flow_rate_si_new = water_use_equipment.waterUseEquipmentDefinition.peakFlowRate # m^3/s
+
+      # report initial condition of model
+      runner.registerInitialCondition("Peak flow rate is #{peak_flow_rate_si_old} m^3/s..")
 
       # report final condition of model
-	  runner.registerFinalCondition("Peak flow rate is #{peak_flow_rate_si_new} m^3/s.")
-
-	end
+      runner.registerFinalCondition("Peak flow rate is #{peak_flow_rate_si_new} m^3/s.")
+    end
 
     return true
-
   end
-
 end
 
 # register the measure to be used by the application