openstudio-workflow 1.0.0 → 1.1.0

data/lib/openstudio/workflow/util/measure.rb

@@ -13,10 +13,10 @@ module OpenStudio
         # @param [Hash] options ({}) User-specified options used to override defaults
         # @option options [Object] :time_logger A special logger used to debug performance issues
         # @option options [Object] :output_adapter An output adapter to register measure transitions to
-        # @option options [Object] :energyplus_output_requests If true then the energyPlusOutputRequests is called instead of the run method
+        # @param  [Boolean] energyplus_output_requests If true then the energyPlusOutputRequests is called instead of the run method
         # @return [Void] 
         #
-        def apply_measures(measure_type, registry, options = {})
+        def apply_measures(measure_type, registry, options = {}, energyplus_output_requests = false)
         
           # DLM: time_logger is in the registry but docs say it is in options?
           registry[:time_logger].start "#{measure_type.valueName}:apply_measures" if registry[:time_logger]
@@ -49,9 +49,9 @@ module OpenStudio
             class_name = measure.className
             measure_instance_type = measure.measureType
             if measure_instance_type == measure_type
-              if options[:energyplus_output_requests]
+              if energyplus_output_requests
                 logger.info "Found measure #{class_name} of type #{measure_type.valueName}. Collecting EnergyPlus Output Requests now."
-                apply_measure(registry, step, options)              
+                apply_measure(registry, step, options, energyplus_output_requests)              
               else
                 logger.info "Found measure #{class_name} of type #{measure_type.valueName}. Applying now."
                 
@@ -193,11 +193,11 @@ module OpenStudio
         # @option options [Array] :measure_search_array Ordered set of measure directories used to search for
         #   step[:measure_dir_name], e.g. ['measures', '../../measures']
         # @option options [Object] :time_logger Special logger used to debug performance issues
-        # @option options [Object] :energyplus_output_requests If true then the energyPlusOutputRequests is called instead of the run method
+        # @param  [Boolean] energyplus_output_requests If true then the energyPlusOutputRequests is called instead of the run method
         # @return [Hash, String] Returns two objects. The first is the (potentially) updated output_attributes hash, and
         #   the second is the (potentially) updated current_weather_filepath
         #
-        def apply_measure(registry, step, options = {})
+        def apply_measure(registry, step, options = {}, energyplus_output_requests = false)
 
           logger = registry[:logger]
           runner = registry[:runner]
@@ -214,7 +214,7 @@ module OpenStudio
           @model = registry[:model]
           @model_idf = registry[:model_idf]
           @sql_filename = registry[:sql]
-
+          
           runner.setLastOpenStudioModel(@model) if @model
           #runner.setLastOpenStudioModelPath(const openstudio::path& lastOpenStudioModelPath); #DLM - deprecate?
           runner.setLastEnergyPlusWorkspace(@model_idf) if @model_idf
@@ -244,7 +244,7 @@ module OpenStudio
             FileUtils.mkdir_p measure_run_dir
             Dir.chdir measure_run_dir
             
-            if options[:energyplus_output_requests]
+            if energyplus_output_requests
               logger.debug "energyPlusOutputRequests running in #{Dir.pwd}"
             else
               logger.debug "Apply measure running in #{Dir.pwd}"
@@ -375,7 +375,7 @@ module OpenStudio
             end
 
             if skip_measure
-              if !options[:energyplus_output_requests]
+              if !energyplus_output_requests
                 # just increment
                 logger.debug "Skipping measure '#{measure_dir_name}'"
                 runner.prepareForUserScriptRun(measure_object)
@@ -387,7 +387,7 @@ module OpenStudio
             else
             
               begin
-                if options[:energyplus_output_requests]
+                if energyplus_output_requests
                   logger.debug "Calling measure.energyPlusOutputRequests for '#{measure_dir_name}'"
                   idf_objects = measure_object.energyPlusOutputRequests(runner, argument_map)
                   num_added = 0
@@ -414,7 +414,7 @@ module OpenStudio
                 # add the error to the osw.out
                 runner.registerError("#{e.message}\n\t#{e.backtrace.join("\n\t")}")
                 
-                if !options[:energyplus_output_requests]
+                if !energyplus_output_requests
                   # incrementStep must be called after run
                   runner.incrementStep
                 end
@@ -424,7 +424,7 @@ module OpenStudio
               end
               
               # if doing output requests we are done now
-              if options[:energyplus_output_requests]
+              if energyplus_output_requests
                 registry.register(:model_idf) { @model_idf }
                 return 
               end
@@ -451,6 +451,28 @@ module OpenStudio
                 registry.register(:model) { @model }
                 registry.register(:model_idf) { @model_idf }
                 registry.register(:sql) { @sql_filename }
+                
+                if measure_type == 'ModelMeasure'.to_MeasureType
+                  # check if weather file has changed
+                  weather_file = @model.getOptionalWeatherFile
+                  if !weather_file.empty?
+                    weather_file_path = weather_file.get.path
+                    if weather_file_path.empty?
+                      logger.debug "Weather file object found in model but no path is given"
+                    else
+                      weather_file_path2 = workflow_json.findFile(weather_file_path.get)
+                      if weather_file_path2.empty?
+                        logger.warn "Could not find weather file '#{weather_file_path}' referenced in model"
+                      else
+                        if weather_file_path2.get.to_s != @wf
+                          logger.debug "Updating weather file path to '#{weather_file_path2.get.to_s}'"
+                          @wf = weather_file_path2.get.to_s
+                          registry.register(:wf) { @wf }
+                        end
+                      end
+                    end
+                  end
+                end
 
               rescue => e
                 log_message = "Runner error #{__FILE__} failed with #{e.message}, #{e.backtrace.join("\n")}"
@@ -511,7 +533,7 @@ module OpenStudio
             Dir.chdir current_dir
             registry[:time_logger].stop("Measure:#{measure_dir_name}") if registry[:time_logger]
 
-            logger.info "Finished #{__method__} for #{measure_dir_name} in #{@registry[:time_logger].delta("Measure:#{measure_dir_name}")} s"
+            logger.info "Finished #{__method__} for #{measure_dir_name} in #{@registry[:time_logger].delta("Measure:#{measure_dir_name}")} s" if registry[:time_logger]
           end
         end
       end

data/lib/openstudio/workflow/version.rb

@@ -19,6 +19,6 @@
 
 module OpenStudio
   module Workflow
-    VERSION = '1.0.0'.freeze # Suffixes must have periods (not dashes)
+    VERSION = '1.1.0'.freeze # Suffixes must have periods (not dashes)
   end
 end

data/lib/openstudio/workflow_json.rb

@@ -396,4 +396,9 @@ class WorkflowJSON_Shim
   def setEplusoutErr(eplusout_err)
     @workflow[:eplusout_err] = eplusout_err
   end
+  
+  # return empty optional
+  def runOptions
+    return Optional_Shim.new(nil)
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: openstudio-workflow
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Nicholas Long
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-01-06 00:00:00.000000000 Z
+date: 2017-02-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -43,15 +43,13 @@ description: Run OpenStudio based measures and simulations using EnergyPlus
 email:
 - nicholas.long@nrel.gov
 - henry.horsey@nrel.gov
-executables:
-- openstudio_cli
+executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - CHANGELOG.md
 - README.md
 - Rakefile
-- bin/openstudio_cli
 - lib/openstudio-workflow.rb
 - lib/openstudio/workflow/adapters/input/local.rb
 - lib/openstudio/workflow/adapters/output/local.rb

data/bin/openstudio_cli

@@ -1,786 +0,0 @@
-#!/usr/bin/env ruby
-
-######################################################################
-#  Copyright (c) 2008-2016, Alliance for Sustainable Energy.
-#  All rights reserved.
-#
-#  This library is free software; you can redistribute it and/or
-#  modify it under the terms of the GNU Lesser General Public
-#  License as published by the Free Software Foundation; either
-#  version 2.1 of the License, or (at your option) any later version.
-#
-#  This library is distributed in the hope that it will be useful,
-#  but WITHOUT ANY WARRANTY; without even the implied warranty of
-#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-#  Lesser General Public License for more details.
-#
-#  You should have received a copy of the GNU Lesser General Public
-#  License along with this library; if not, write to the Free Software
-#  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-######################################################################
-
-Signal.trap('INT') { abort }
-
-require 'openstudio-workflow'
-require 'optparse'
-require 'irb'
-require 'json'
-include OpenStudio::Workflow::Util::IO
-include OpenStudio::Workflow::Util::Directory
-
-$logger = Logger.new(STDOUT)
-$logger.level = Logger::WARN
-
-# This is the code chunk to allow for an embedded IRB shell. From Jason Roelofs, found on StackOverflow
-module IRB # :nodoc:
-  def self.start_session(binding)
-    unless @__initialized
-      args = ARGV
-      ARGV.replace(ARGV.dup)
-      IRB.setup(nil)
-      ARGV.replace(args)
-      @__initialized = true
-    end
-
-    workspace = WorkSpace.new(binding)
-
-    irb = Irb.new(workspace)
-
-    @CONF[:IRB_RC].call(irb.context) if @CONF[:IRB_RC]
-    @CONF[:MAIN_CONTEXT] = irb.context
-
-    catch(:IRB_EXIT) do
-      irb.eval_input
-    end
-  end
-end
-
-# This is the save puts to use to catch EPIPE. Uses `puts` on the given IO object and safely ignores any Errno::EPIPE
-#
-# @param [String] message Message to output
-# @param [Hash] opts Options hash
-#
-def safe_puts(message = nil, opts = nil)
-  message ||= ''
-  opts = {
-    io: $stdout,
-    printer: :puts
-  }.merge(opts || {})
-
-  begin
-    opts[:io].send(opts[:printer], message)
-  rescue Errno::EPIPE
-    # This is what makes this a `safe` puts
-    return
-  end
-end
-
-# This is a convenience method that properly handles duping the originally argv array so that it is not destroyed. This
-# method will also automatically detect "-h" and "--help" and print help. And if any invalid options are  detected, the
-# help will be printed, as well
-#
-# @param [Object, nil] opts An instance of OptionParse to parse against, defaults to a new OptionParse instance
-# @param [Array, nil] argv The argv input to be parsed, defaults to $argv
-# @return[Array, nil] If this method returns `nil`, then you should assume that help was printed and parsing failed
-#
-def parse_options(opts = nil, argv = nil)
-  # Creating a shallow copy of the arguments so the OptionParser
-  # doesn't destroy the originals.
-  argv ||= $argv.dup
-
-  # Default opts to a blank optionparser if none is given
-  opts ||= OptionParser.new
-
-  # Add the help option, which must be on every command.
-  opts.on_tail('-h', '--help', 'Print this help') do
-    safe_puts(opts.help)
-    return nil
-  end
-
-  opts.parse!(argv)
-  return argv
-rescue OptionParser::InvalidOption, OptionParser::MissingArgument
-  raise "Error: Invalid CLI option, #{opts.help.chomp}"
-end
-
-# This method will split the argv given into three parts: the flags to this command, the subcommand, and the flags to
-# the subcommand. For example:
-#     -v status -h -v
-# The above would yield 3 parts:
-#     ["-v"]
-#     "status"
-#     ["-h", "-v"]
-# These parts are useful because the first is a list of arguments given to the current command, the second is a
-# subcommand, and the third are the commands given to the subcommand
-#
-# @param [Array] argv The input to be split
-# @return [Array] The split command as [main arguments, sub command, sub command arguments]
-#
-def split_main_and_subcommand(argv)
-  # Initialize return variables
-  main_args   = nil
-  sub_command = nil
-  sub_args    = []
-
-  # We split the arguments into two: One set containing any flags before a word, and then the rest. The rest are what
-  # get actually sent on to the subcommand
-  argv.each_index do |i|
-    unless argv[i].start_with?('-')
-      # We found the beginning of the sub command. Split the
-      # args up.
-      main_args   = argv[0, i]
-      sub_command = argv[i]
-      sub_args    = argv[i + 1, argv.length - i + 1]
-
-      # Break so we don't find the next non flag and shift our main args
-      break
-    end
-  end
-
-  # Handle the case that argv was empty or didn't contain any subcommand
-  main_args = argv.dup if main_args.nil?
-
-  [main_args, sub_command, sub_args]
-end
-
-# This CLI class processes the input args and invokes the proper command class
-class CLI
-  # This constant maps subcommands to classes in this CLI and stores meta-data on them
-  COMMAND_LIST = {
-    run: [proc { ::Run }, { primary: true, working: true }],
-    apply_measure: [proc { ::ApplyMeasure }, { primary: true, working: false }],
-    gem_list: [proc { ::GemList }, { primary: true, working: true }],
-    gem_install: [proc { ::InstallGem }, { primary: false, working: true }],
-    measure: [proc { ::Measure }, { primary: true, working: false }],
-    e: [proc { ::ExecuteRubyScript }, { primary: false, working: true }],
-    i: [proc { ::InteractiveRubyShell }, { primary: false, working: true }],
-    openstudio_version: [proc { ::OpenStudioVersion }, { primary: true, working: true }],
-    energyplus_version: [proc { ::EnergyPlusVersion }, { primary: true, working: true }],
-    ruby_version: [proc { ::RubyVersion }, { primary: false, working: true }],
-    list_commands: [proc { ::ListCommands }, { primary: true, working: true }]
-  }.freeze
-
-  # This method instantiates the global variables $main_args, $sub_command, and $sub_args
-  #
-  # @param [Array] argv The arguments passed through the CLI
-  # @return [Object] An instance of the CLI class with initialized globals
-  #
-  def initialize(argv)
-    $main_args, $sub_command, $sub_args = split_main_and_subcommand(argv)
-
-    $logger.info("CLI Parsed Inputs: #{$main_args.inspect} #{$sub_command.inspect} #{$sub_args.inspect}")
-  end
-
-  # Checks to see if it should print the main help, and if not parses the subcommand into a class and executes it
-  def execute
-    $logger.debug "Main arguments are #{$main_args}"
-    $logger.debug "Sub-command is #{$sub_command}"
-    $logger.debug "Sub-arguments are #{$sub_args}"
-    if $main_args.include?('-h') || $main_args.include?('--help')
-      # Help is next in short-circuiting everything. Print
-      # the help and exit.
-      help
-      return 0
-    end
-
-    # If we reached this far then we must have a subcommand. If not,
-    # then we also just print the help and exit.
-    command_plugin = nil
-    if $sub_command
-      command_plugin = COMMAND_LIST[$sub_command.to_sym]
-    end
-
-    if !command_plugin || !$sub_command
-      help
-      return 1
-    end
-
-    command_class = command_plugin[0].call
-    $logger.debug("Invoking command class: #{command_class} #{$sub_args.inspect}")
-
-    # Initialize and execute the command class, returning the exit status.
-    result = 0
-    begin
-      result = command_class.new.execute($sub_args)
-    rescue Interrupt
-      $logger.error '?'
-      result = 1
-    end
-
-    result = 0 unless result.is_a?(Fixnum)
-    result
-  end
-
-  # Prints out the help text for the CLI
-  #
-  # @param [Boolean] list_all If set to true, the help prints all commands, however it otherwise only prints those
-  #   marked as primary in #COMMAND_LIST
-  # @return [void]
-  # @see #COMMAND_LIST #::ListCommands
-  #
-  def help(list_all = false)
-    opts = OptionParser.new do |o|
-      o.banner = 'Usage: openstudio_cli [options] <command> [<args>]'
-      o.separator ''
-      o.on('-h', '--help', 'Print this help.')
-      o.on('--verbose', 'Print the full log to STDOUT')
-      o.on('--gem_path PATH', 'Path to use for installing gems to and loading gems from')
-      o.separator ''
-      o.separator 'Common commands:'
-
-      # Add the available subcommands as separators in order to print them
-      # out as well.
-      commands = {}
-      longest = 0
-      COMMAND_LIST.each do |key, data|
-        # Skip non-primary commands. These only show up in extended
-        # help output.
-        next unless list_all || data[1][:primary]
-
-        key           = key.to_s
-        klass         = data[0].call
-        commands[key] = klass.synopsis
-        longest       = key.length if key.length > longest
-      end
-
-      commands.keys.sort.each do |key|
-        o.separator "     #{key.ljust(longest + 2)} #{commands[key]}"
-      end
-
-      o.separator ''
-      o.separator 'For help on any individual command run `openstudio_cli COMMAND -h`'
-      unless list_all
-        o.separator ''
-        o.separator 'Additional subcommands are available, but are either more advanced'
-        o.separator 'or not commonly used. To see all subcommands, run the command'
-        o.separator '`openstudio_cli list_commands`.'
-      end
-    end
-
-    safe_puts opts.help
-  end
-end
-
-# Class to execute part or all of an OSW workflow
-class Run
-  # Provides text for the main help functionality
-  def self.synopsis
-    'Executes an OpenStudio Workflow file'
-  end
-
-  # Executes the standard, or one of two custom, workflows using the workflow-gem
-  #
-  # @param [Array] sub_argv Options passed to the run subcommand from the user input
-  # @return [Fixnum] Return status
-  #
-  def execute(sub_argv)
-    options = {}
-    options[:debug] = false
-    options[:no_simulation] = false
-    options[:workflow] = './workflow.osw'
-    options[:post_process] = false
-
-    opts = OptionParser.new do |o|
-      o.banner = 'Usage: openstudio_cli run [options]'
-      o.separator ''
-      o.separator 'Options:'
-      o.separator ''
-
-      o.on('-w', '--workflow [FILE]', 'Specify the FILE path to the workflow to run') do |workflow|
-        options[:workflow] = workflow
-      end
-      o.on('-m', '--measures_only', 'Only run the OpenStudio and EnergyPlus measures') do
-        options[:no_simulation] = true
-      end
-      o.on('-p', '--postprocess_only', 'Only run the reporting measures') do
-        options[:post_process] = true
-      end
-      o.on('--debug', 'Includes additional outputs for debugging failing workflows and does not clean up the run directory') do |f|
-        options[:debug] = f
-      end
-    end
-
-    # Parse the options
-    argv = parse_options(opts, sub_argv)
-    return 0 if argv.nil?
-    unless argv == []
-      $logger.error 'Extra arguments passed to the run command. Please refer to the help documentation.'
-      return 1
-    end
-    $logger.debug("Run command: #{argv.inspect} #{options.inspect}")
-
-    if options[:post_process] && options[:no_simulation]
-      $logger.error 'Both the -m and -p flags were set, which is an invalid combination.'
-      return 1
-    end
-
-    osw_path = options[:workflow]
-    osw_path = File.absolute_path(File.join(Dir.pwd, osw_path)) unless Pathname.new(osw_path).absolute?
-    $logger.debug "Path for the OSW: #{osw_path}"
-
-    adapter_options = { workflow_filename: File.basename(osw_path) }
-    input_adapter = OpenStudio::Workflow.load_input_adapter 'local', adapter_options
-    adapter_options[:output_directory] = input_adapter.run_directory File.dirname(osw_path)
-    output_adapter = OpenStudio::Workflow.load_output_adapter 'local', adapter_options
-    run_options = options[:debug] ? { debug: true, cleanup: false } : {}
-    if options[:no_simulation]
-      run_options[:jobs] = [
-        { state: :queued, next_state: :initialization, options: { initial: true } },
-        { state: :initialization, next_state: :os_measures, job: :RunInitialization,
-          file: 'openstudio/workflow/jobs/run_initialization.rb', options: {} },
-        { state: :os_measures, next_state: :translator, job: :RunOpenStudioMeasures,
-          file: 'openstudio/workflow/jobs/run_os_measures.rb', options: {} },
-        { state: :translator, next_state: :ep_measures, job: :RunTranslation,
-          file: 'openstudio/workflow/jobs/run_translation.rb', options: {} },
-        { state: :ep_measures, next_state: :finished, job: :RunEnergyPlusMeasures,
-          file: 'openstudio/workflow/jobs/run_ep_measures.rb', options: {} },
-        { state: :finished },
-        { state: :errored }
-      ]
-    elsif options[:post_process]
-      run_options[:jobs] = [
-        { state: :queued, next_state: :initialization, options: { initial: true } },
-        { state: :initialization, next_state: :reporting_measures, job: :RunInitialization,
-          file: 'openstudio/workflow/jobs/run_initialization.rb', options: {} },
-        { state: :reporting_measures, next_state: :postprocess, job: :RunReportingMeasures,
-          file: 'openstudio/workflow/jobs/run_reporting_measures.rb', options: {} },
-        { state: :postprocess, next_state: :finished, job: :RunPostprocess,
-          file: 'openstudio/workflow/jobs/run_postprocess.rb', options: {} },
-        { state: :finished },
-        { state: :errored }
-      ]
-      run_options[:load_simulation_osm] = true
-      run_options[:load_simulation_idf] = true
-      run_options[:load_simulation_sql] = true
-      run_options[:preserve_run_dir] = true
-    end
-    k = OpenStudio::Workflow::Run.new input_adapter, output_adapter, File.dirname(osw_path), run_options
-    k.run
-
-    0
-  end
-end
-
-# Class to apply an OpenStudio, EnergyPlus, or Reporting measure
-# @abstract
-class ApplyMeasure
-  # Provides text for the main help functionality
-  def self.synopsis
-    'Applies an OpenStudio, EnergyPlus, or Reporting measure'
-  end
-
-  # Executes a single measure using an undefined interface
-  #
-  # @param [Array] sub_argv Options passed to the apply_measures subcommand from the user input
-  # @return [Fixnum] Return status
-  # @abstract
-  #
-  def execute(sub_argv)
-    # options = {}
-    # options[:debug] = false
-
-    # opts = OptionParser.new do |o|
-    #   o.banner = 'Usage: openstudio_cli apply_measure'
-    #   o.separator ''
-    #   o.separator 'Options:'
-    #   o.separator ''
-    # end
-
-    $logger.error 'This interface has yet to be defined.'
-
-    # Parse the options
-    argv = parse_options(opts, sub_argv)
-    return 1 unless argv
-    # $logger.debug("ApplyMeasure command: #{argv.inspect} #{options.inspect}")
-
-    1
-  end
-end
-
-# Class to list the gems used by the CLI
-class GemList
-  # Provides text for the main help functionality
-  def self.synopsis
-    'Lists the set gems available to openstudio_cli'
-  end
-
-  # Alters the environment variable used to define the gem install location
-  #
-  # @param [Array] sub_argv Options passed to the gem_install subcommand from the user input
-  # @return [Fixnum] Return status
-  #
-  def execute(sub_argv)
-    require 'rubygems'
-    require 'rubygems/gem_runner'
-
-    # Parse the options
-    opts = OptionParser.new do |o|
-      o.banner = 'Usage: openstudio_cli gem_list'
-    end
-    argv = parse_options(opts, sub_argv)
-    unless argv == []
-      $logger.error 'Extra arguments passed to the gem_list command. Please refer to the help documentation.'
-      return 1
-    end
-
-    begin
-      Gem::GemRunner.new.run ['list']
-    rescue => e
-      $logger.error "Error listing gems: #{e.message} in #{e.backtrace.join("\n")}"
-      exit e.exit_code
-    end
-
-    0
-  end
-end
-
-# Class to install gems using the RubyGems functionality
-class InstallGem
-  # Provides text for the main help functionality
-  def self.synopsis
-    'Installs a Gem using the embedded ruby'
-  end
-
-  # Executes the RubyGems gem install process, using the RubyGems options
-  #
-  # @param [Array] sub_argv Options passed to the gem_install subcommand from the user input
-  # @return [Fixnum] Return status
-  #
-  def execute(sub_argv)
-    require 'rubygems'
-    require 'rubygems/gem_runner'
-
-    # Parse the options
-    argv = sub_argv.unshift('install')
-    if argv.include? '--install-dir'
-      $logger.error 'The rubygems option --install-dir is not supported. Please use the --gem_path option'
-      return 1
-    else
-      argv.push '--install-dir'
-      argv.push ENV['GEM_PATH']
-    end
-    $logger.debug "GemInstall command: #{argv.inspect}"
-    $logger.debug "Invoking the GemRunner with argv: #{argv}"
-
-    begin
-      Gem::GemRunner.new.run argv
-    rescue => e
-      $logger.error "Error installing gem: #{e.message} in #{e.backtrace.join("\n")}"
-      exit e.exit_code
-    end
-
-    $logger.info 'The gem was successfully installed'
-
-    0
-  end
-end
-
-# Class to update measures and compute arguments
-class Measure
-  # Provides text for the main help functionality
-  def self.synopsis
-    'Updates measures and compute arguments'
-  end
-
-  # Executes code to update and compute arguments for measures
-  #
-  # @param [Array] sub_argv Options passed to the e subcommand from the user input
-  # @return [Fixnum] Return status
-  # @todo (macumber) Add in the OpenStudio code to execute on measures
-  #
-  def execute(sub_argv)
-    options = {}
-    options[:check_for_update] = false
-    options[:update] = false
-    options[:compute_arguments] = nil
-
-    opts = OptionParser.new do |o|
-      o.banner = 'Usage: openstudio_cli measure [options] DIRECTORY'
-      o.separator ''
-      o.separator 'Options:'
-      o.separator ''
-
-      o.on('-c', '--check_for_updates', 'Check to see if the measure needs to be updated') do
-        options[:check_for_update] = workflow
-      end
-      o.on('-u', '--update', 'Update the measure.xml') do
-        options[:update] = true
-      end
-      o.on('-a', '--compute_arguments [MODEL]', 'Compute arguments for the given model') do |model_file|
-        options[:compute_arguments] = model_file
-      end
-    end
-
-    # Parse the options
-    argv = parse_options(opts, sub_argv)
-    $logger.error 'No directory provided' if argv == []
-    return 1 if argv == []
-    directory = argv[0]
-
-    $logger.debug("Measure command: #{argv.inspect} #{options.inspect}")
-    $logger.debug("Directory to examine is #{directory}")
-
-    $logger.error 'Code to be added here to operate on measures'
-
-    1
-  end
-end
-
-# Class to execute a ruby script
-class ExecuteRubyScript
-  # Provides text for the main help functionality
-  def self.synopsis
-    'Executes a ruby file'
-  end
-
-  # Executes an arbitrary ruby script
-  #
-  # @param [Array] sub_argv Options passed to the e subcommand from the user input
-  # @return [Fixnum] Return status
-  #
-  def execute(sub_argv)
-    options = {}
-
-    opts = OptionParser.new do |o|
-      o.banner = 'Usage: openstudio_cli e [file]'
-    end
-
-    # Parse the options
-    argv = parse_options(opts, sub_argv)
-    return 0 if argv.nil?
-    return 1 unless argv
-    $logger.debug("ExecuteRubyScript command: #{argv.inspect} #{options.inspect}")
-    file_path = argv.shift.to_s
-    file_path = File.absolute_path(File.join(Dir.pwd, file_path)) unless Pathname.new(file_path).absolute?
-    $logger.debug "Path for the file to run: #{file_path}"
-
-    unless argv == []
-      $logger.error 'Extra arguments passed to the e command. Please refer to the help documentation.'
-      return 1
-    end
-
-    unless File.exist? file_path
-      $logger.error "Unable to find the file #{file_path} on the filesystem"
-      return 1
-    end
-
-    require file_path
-
-    0
-  end
-end
-
-# Class to put the user into an irb shell
-class InteractiveRubyShell
-  # Provides text for the main help functionality
-  def self.synopsis
-    'Provides an interactive ruby shell'
-  end
-
-  # Executes the commands to get into an IRB prompt
-  #
-  # @param [Array] sub_argv Options passed to the i subcommand from the user input
-  # @return [Fixnum] Return status
-  #
-  def execute(sub_argv)
-    options = {}
-
-    opts = OptionParser.new do |o|
-      o.banner = 'Usage: openstudio_cli i'
-    end
-
-    # Parse the options
-    argv = parse_options(opts, sub_argv)
-    $logger.debug("InteractiveRubyShell command: #{argv.inspect} #{options.inspect}")
-    return 0 if argv.nil?
-
-    unless argv == []
-      $logger.error 'Extra arguments passed to the i command.'
-      return 1
-    end
-
-    IRB.start_session(binding)
-
-    0
-  end
-end
-
-# Class to return the packaged OpenStudio version
-class OpenStudioVersion
-  # Provides text for the main help functionality
-  def self.synopsis
-    'Returns the OpenStudio version used by the CLI'
-  end
-
-  # Executes the OpenStudio commands to return the OpenStudio version
-  #
-  # @param [Array] sub_argv Options passed to the energyplus_version subcommand from the user input
-  # @return [Fixnum] Return status
-  #
-  def execute(sub_argv)
-    options = {}
-
-    opts = OptionParser.new do |o|
-      o.banner = 'Usage: openstudio_cli openstudio_version'
-    end
-
-    # Parse the options
-    argv = parse_options(opts, sub_argv)
-    $logger.debug("OpenStudioVersion command: #{argv.inspect} #{options.inspect}")
-    return 0 if argv.nil?
-
-    unless argv == []
-      $logger.error 'Extra arguments passed to the openstudio_version command.'
-      return 1
-    end
-
-    safe_puts OpenStudio.openStudioLongVersion
-
-    0
-  end
-end
-
-# Class to return the EnergyPlus version
-class EnergyPlusVersion
-  # Provides text for the main help functionality
-  def self.synopsis
-    'Returns the EnergyPlus version used by the CLI'
-  end
-
-  # Executes the OpenStudio command to return the EnergyPlus version
-  #
-  # @param [Array] sub_argv Options passed to the openstudio_version subcommand from the user input
-  # @return [Fixnum] Return status
-  #
-  def execute(sub_argv)
-    options = {}
-
-    opts = OptionParser.new do |o|
-      o.banner = 'Usage: openstudio_cli energyplus_version'
-    end
-
-    # Parse the options
-    argv = parse_options(opts, sub_argv)
-    $logger.debug("EnergyPlusVersion command: #{argv.inspect} #{options.inspect}")
-    return 0 if argv.nil?
-
-    unless argv == []
-      $logger.error 'Arguments passed to the energyplus_version command.'
-      return 1
-    end
-
-    safe_puts OpenStudio.energyPlusVersion
-
-    0
-  end
-end
-
-# Class to return the ruby version used by the packaged CLI
-class RubyVersion
-  # Provides text for the main help functionality
-  def self.synopsis
-    'Returns the Ruby version used by the CLI'
-  end
-
-  # Evaluates the RUBY_VERSION constant and returns it
-  #
-  # @param [Array] sub_argv Options passed to the ruby_version subcommand from the user input
-  # @return [Fixnum] Return status
-  #
-  def execute(sub_argv)
-    options = {}
-
-    opts = OptionParser.new do |o|
-      o.banner = 'Usage: openstudio_cli ruby_version'
-    end
-
-    # Parse the options
-    argv = parse_options(opts, sub_argv)
-    $logger.debug("RubyVersion command: #{argv.inspect} #{options.inspect}")
-    return 0 if argv.nil?
-
-    unless argv == []
-      $logger.error 'Arguments passed to the ruby_version command.'
-      return 1
-    end
-
-    safe_puts RUBY_VERSION
-
-    0
-  end
-end
-
-# Class to return the full set of possible commands for the CLI
-class ListCommands
-  # Provides text for the main help functionality
-  def self.synopsis
-    'Lists the entire set of available commands for openstudio_cli'
-  end
-
-  # Executes the standard help method with the list_all attribute set to true
-  #
-  # @param [Array] sub_argv Options passed to the list_all subcommand from the user input
-  # @return [Fixnum] Return status
-  # @see #::CLI.help
-  #
-  def execute(sub_argv)
-    options = {}
-
-    opts = OptionParser.new do |o|
-      o.banner = 'Usage: openstudio_cli list_commands'
-    end
-
-    # Parse the options
-    argv = parse_options(opts, sub_argv)
-    $logger.debug("ListCommands command: #{argv.inspect} #{options.inspect}")
-    return 0 if argv.nil?
-
-    unless argv == []
-      $logger.error 'Arguments passed to the list_commands command.'
-      return 1
-    end
-
-    $logger.debug 'Creating a new CLI instance and calling help with list_all enabled'
-    ::CLI.new([]).help(true)
-
-    0
-  end
-end
-
-# Set the logger level to DEBUG if the arguments include --verbose
-$argv = ARGV.dup
-if $argv.include? '--verbose'
-  $logger.level = Logger::DEBUG
-  $argv.delete '--verbose'
-  $logger.debug 'Set Logger log level to DEBUG'
-end
-$logger.debug "Input ARGV is #{$argv}"
-
-# Operate on the gem_path option to set the gem search path
-if $argv.include? '--gem_path'
-  $logger.info 'Setting gem path'
-  option_index = $argv.index '--gem_path'
-  path_index = option_index + 1
-  new_home = $argv[path_index]
-  $argv.slice! path_index
-  $argv.slice! $argv.index '--gem_path'
-  current_home = ENV['OPENSTUDIO_GEM_PATH']
-  $logger.warn "Overwriting previous OPENSTUDIO_GEM_PATH of #{current_home} to #{new_home} for this command" if current_home
-  $logger.info "No current gem path set in OPENSTUDIO_GEM_PATH, setting to #{new_home}" unless current_home
-  ENV['OPENSTUDIO_GEM_PATH'] = new_home
-end
-
-# Configure Gems to load the correct Gem files
-# @see http://rubygems.rubyforge.org/rubygems-update/Gem.html
-local_dir = ENV['OPENSTUDIO_GEM_PATH'] ? ENV['OPENSTUDIO_GEM_PATH'] : "~/OpenStudio/v#{OpenStudio.openStudioVersion}"
-local_dir = File.absolute_path(local_dir)
-ENV['GEM_PATH'] = OpenStudio::Workflow::Util::IO.is_windows? ? local_dir.tr('/', '\\') : local_dir
-$logger.debug "Set environment variable GEM_PATH to #{ENV['GEM_PATH']}"
-ENV['GEM_HOME'] = OpenStudio::Workflow::Util::IO.is_windows? ? '\\' : '/'
-$logger.debug "Set environment variable GEM_HOME to #{ENV['GEM_HOME']}"
-Gem.clear_paths
-$logger.debug 'Reset Gem paths; openstudio_cli associated gems should load correctly'
-
-# Execute the CLI interface, and exit with the proper error code
-$logger.info "Executing argv: #{$argv}"
-CLI.new($argv).execute