urbanopt-cli 0.2.3 → 0.3.0.pre1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 45f2908aa6ed3a360029d8a474276fe27d3e1d02
-  data.tar.gz: a39f3810ddacfa43a0a2b36cfb5860bea5b514d5
+SHA256:
+  metadata.gz: 300f91ac0998cd778f0cc3a1e250920ef9b4c522170b259b6d670353bb49bd78
+  data.tar.gz: fc8c993cc405be6a972d9e3126bce4df1b4ee983a9797df3a638829190e7f9d5
 SHA512:
-  metadata.gz: afa12d95c62d4fb01c10f4d7c79951c12fa7b85d972c41b5c1a77704d496da189c29b1e9ba5c7b21573ed614187474600136504aa3fc752fd3ef9f45fee75a08
-  data.tar.gz: 8acba12c2a7b36fba84f002286fa878de9577ffb9f29aae865bf5ef39fd102c458925ef3bec2e7cce5564048b266bea7e59021efe5fd669350f85a20d90fa66e
+  metadata.gz: ebd6d8338f24f1f1a90dbe790971e9e76ae2fe6017f8536a062b60daf4954aa11d574b13fee67a62469376007dd8d2e902d26f98bc3bd21fe86eae4340813a2d
+  data.tar.gz: 5e3ec3f318c88138869b4001f0ac3b01f1b584904c411036399c65ca07886d62e3027945bca86c5702bf571150cd86a63bceaea13c2c41c826bdabbd6593d63f

data/.ruby-version

@@ -1 +1 @@
-2.2.4
+2.5.1

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## Version 0.3.0.pre1
+
+Date Range: 04/23/20 - 05/20/20
+
+Update to OpenStudio 3.x and Ruby 2.5.x
+
 ## Version 0.2.3
 
 Date Range: 04/01/20 - 04/23/20:

data/Gemfile

@@ -1,12 +1,8 @@
 source 'http://rubygems.org'
 
-# Specify your gem's dependencies in uo_cli.gemspec
+# Specify dependencies in uo_cli.gemspec
 gemspec
 
-# simplecov has a dependency on native json gem, use fork that does not require this
-gem 'certified'
-gem 'simplecov', github: 'NREL/simplecov'
-
 # Local gems are useful when developing and integrating the various dependencies.
 # To favor the use of local gems, set the following environment variable:
 #   Mac: export FAVOR_LOCAL_GEMS=1

data/README.md

@@ -27,48 +27,61 @@ gem install urbanopt-cli
 For help text in your terminal, type:
 
 ```terminal
-uo -h
+uo --help
 ```
 
 Create a project folder:
 
 ```terminal
-uo -p <FOLDERNAME>
+uo create --project-folder <FOLDERNAME>
 ```
 
 Overwrite an existing project folder:
 
 ```terminal
-uo -o -p <FOLDERNAME>
+uo create --overwrite --project-folder <FOLDERNAME>
 ```
 
 Create an empty project folder without the example files:
 
 ```terminal
-uo -e -p <FOLDERNAME>
+uo create --empty --project-folder <FOLDERNAME>
+```
+
+Create ScenarioFiles from a FeatureFile using MapperFiles:
+
+```terminal
+uo create --scenario-file <FEATUREFILE>
+```
 
-Make ScenarioFiles from a FeatureFile using MapperFiles:
+Create a ScenarioFile using only a specific FEATURE_ID from a FEATUREFILE:
 
 ```terminal
-uo -m -f <FEATUREFILE>
+uo create --scenario-file <FEATUREFILE> --single-feature <FEATURE_ID>
 ```
 
-Make a ScenarioFile using only a specific FEATURE_ID from a FEATUREFILE:
+Create a REopt ScenarioFile from an existing ScenarioFile:
 
 ```terminal
-uo -m -f <FEATUREFILE> -i <FEATURE_ID>
+uo create --reopt-scenario-file baseline_scenario.csv
 ```
 
 Run URBANopt energy simulations for each feature in your scenario:
 
 ```terminal
-uo -r -s <SCENARIOFILE> -f <FEATUREFILE>
+uo run --scenario <SCENARIOFILE> --feature <FEATUREFILE>
+```
+
+Run URBANopt energy simulations for each feature in your scenario, with REopt functionality included:
+
+```terminal
+uo run --reopt --scenario <SCENARIOFILE> --feature <FEATUREFILE>
 ```
 
-Gather simulations for a full scenario:
+Post-process simulations for a full scenario:
 
 ```terminal
-uo -g -t <TYPE> -s <SCENARIOFILE> -f <FEATUREFILE>
+uo process --<TYPE> --scenario <SCENARIOFILE> --feature <FEATUREFILE>
 ```
 
 - Valid `TYPE`s are: `default`, `opendss`, `reopt-scenario`, `reopt-feature`
@@ -76,15 +89,15 @@ uo -g -t <TYPE> -s <SCENARIOFILE> -f <FEATUREFILE>
 Delete a scenario you have already run:
 
 ```terminal
-uo -d -s <SCENARIOFILE>
+uo delete --scenario <SCENARIOFILE>
 ```
 
 Installed CLI version:
 
 ```terminal
-uo -v
+uo --version
 ```
 
 ## Development
 
-To install this gem onto your local machine, clone this repo and run `bundle exec rake install`. If you make changes to this repo, update the version number in `lib/version.rb` in your first commit. When ready to release, run the changelog script at `lib/change_log.rb` and copy the appropriate portion of the output into `CHANGELOG.md`. Run `bundle exec rake release` which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+To install this gem onto your local machine, clone this repo and run `bundle exec rake install`. If you make changes to this repo, update the version number in `lib/version.rb` in your first commit. When ready to release, [follow the documentation](https://docs.urbanopt.net/developer_resources/release_instructions.html).

data/example_files/Gemfile

@@ -1,6 +1,6 @@
 source 'http://rubygems.org'
 
-ruby '2.2.4'
+ruby '~> 2.5.0'
 
 # Local gems are useful when developing and integrating the various dependencies.
 # To favor the use of local gems, set the following environment variable:
@@ -46,14 +46,14 @@ allow_local = ENV['FAVOR_LOCAL_GEMS']
 #   gem 'openstudio-model-articulation', '0.1.0'
 # end
 
-gem 'urbanopt-reopt', '0.2.1'
+gem 'urbanopt-reopt', '0.3.0.pre1'
 
 if allow_local && File.exist?('../urbanopt-scenario-gem')
   gem 'urbanopt-scenario', path: '../urbanopt-scenario-gem'
 elsif allow_local
   gem 'urbanopt-scenario', github: 'URBANopt/urbanopt-scenario-gem', branch: 'develop'
 else
-  gem 'urbanopt-scenario', '0.2.0'
+  gem 'urbanopt-scenario', '0.3.0.pre1'
 end
 
 if allow_local && File.exist?('../urbanopt-geojson-gem')
@@ -61,11 +61,5 @@ if allow_local && File.exist?('../urbanopt-geojson-gem')
 elsif allow_local
   gem 'urbanopt-geojson', github: 'URBANopt/urbanopt-geojson-gem', branch: 'develop'
 else
-  gem 'urbanopt-geojson', '0.2.0'
+  gem 'urbanopt-geojson', '0.3.0.pre1'
 end
-
-# simplecov has an unneccesary dependency on native json gem, use fork that does not require this
-gem 'simplecov', github: 'NREL/simplecov'
-
-# Specify exact rack version temporarily to work with Ruby 2.2.4
-gem 'rack', '2.1.2'

data/lib/uo_cli/version.rb

@@ -1,5 +1,5 @@
 module URBANopt
   module CLI
-    VERSION = '0.2.3'.freeze
+    VERSION = '0.3.0.pre1'.freeze
   end
 end

data/lib/uo_cli.rb

@@ -31,7 +31,7 @@
 # *********************************************************************************
 
 require 'uo_cli/version'
-require 'optparse'
+require 'optimist'
 require 'urbanopt/geojson'
 require 'urbanopt/scenario'
 require 'urbanopt/reopt'
@@ -43,91 +43,139 @@ require_relative '../developer_nrel_key'
 
 module URBANopt
   module CLI
-    # Set up user interface
-    @user_input = {}
-    the_parser = OptionParser.new do |opts|
-      opts.banner = "\nUsage: uo [-peomrgdsfitv]\n" \
-                    "\n" \
-                    "URBANopt CLI\n" \
-                    "First create a project folder with -p, then run additional commands as desired\n" \
-                    "Additional config options can be set with the 'runner.conf' file inside your new project folder"
-      opts.separator ''
-
-      opts.on('-p', '--project_folder <DIR>', String, "Create project directory named <DIR> in your current folder\n" \
-          "                                     Fewer warnings are presented when using full paths and the user is not inside the project folder\n\n") do |folder|
-        @user_input[:project_folder] = folder
+    class UrbanOptCLI
+      COMMAND_MAP = {
+        'create' => 'Make new things - project directory or files',
+        'run' => 'Use files in your directory to simulate district energy use',
+        'process' => 'Post-process URBANopt simulations for additional insights',
+        'delete' => 'Delete simulations for a specified scenario'
+      }.freeze
+
+      def initialize
+        @subopts = nil
+        @command = nil
+        @mainopts = Optimist.options do
+          version VERSION
+          banner "\nURBANopt CLI version: #{version}"
+          banner "\nUsage:"
+          banner "  uo [options] [<command> [suboptions]]\n \n"
+          banner 'Options:'
+          opt :version, 'Print version and exit'  ## add this here or it goes to bottom of help
+          opt :help, 'Show this help message'     ## add this here or it goes to bottom of help
+          # opt :no_pager, "Disable paging"
+          stop_on COMMAND_MAP.keys
+          banner "\nCommands:"
+          COMMAND_MAP.each { |cmd, desc| banner format('  %-10s %s', cmd, desc) }
+          banner "\nFor help with a specific command: uo <command> --help"
+          banner "\nAdditional config options can be set with the 'runner.conf' file inside your project folder"
+          banner 'Fewer warnings are presented when using full paths and the user is not inside the project folder'
+        end
+        return if ARGV.empty?
+        @command = ARGV.shift
+        send("opt_#{@command}") ## dispatch to command handling method
       end
 
-      opts.on('-e', '--empty_project_folder', String, "Use with -p argument to create an empty project folder\n" \
-          "                                     Example: uo -e -p <DIR>\n" \
-          "                                     Then add your own Feature file in the project directory you created,\n" \
-          "                                     add Weather files in the weather folder and add OpenStudio models of Features\n" \
-          "                                     in the Feature File, if any, in the osm_building folder\n" \
-          "                                     Fewer warnings are presented when using full paths and the user is not inside the project folder\n\n") do
-        @user_input[:empty_project_folder] = 'Create empty project folder' # This text does not get displayed to the user
+      # Define creation commands
+      def opt_create
+        cmd = @command
+        @subopts = Optimist.options do
+          banner "\nURBANopt #{cmd}:\n \n"
+
+          opt :project_folder, "\nCreate project directory in your current folder. Name the directory\n" \
+          'Example: uo create --project urbanopt_example_project', type: String
+
+          opt :empty, "\nUse with --project-folder argument to create an empty project folder\n" \
+          "Then add your own Feature file in the project directory you created,\n" \
+          "add Weather files in the weather folder and add OpenStudio models of Features\n" \
+          "in the Feature File, if any, in the osm_building folder\n" \
+          "Example: uo create --empty --project-folder urbanopt_example_project\n" \
+
+          opt :overwrite, "\nUse with --project-folder argument to overwrite existing project folder and replace with new project folder.\n" \
+          "May be combined with --empty as well to overwrite existing project folder and replace with new empty project folder.\n" \
+          'Example: uo create --overwrite --empty --project-folder urbanopt_project_folder_I_want_destroyed'
+
+          opt :scenario_file, "\nAutomatically create a ScenarioFile containing the features in FeatureFile for each scenario\n" \
+          "Provide the FeatureFile used to create the ScenarioFile\n" \
+          'Example: uo create --scenario-file example_project.json', type: String
+
+          opt :single_feature, "\nCreate a ScenarioFile with only a single feature\n" \
+          "Use the FeatureID from your FeatureFile\n" \
+          "Requires 'scenario-file' also be specified, to say which FeatureFile will create the ScenarioFile\n" \
+          'Example: uo create --single-feature 2 --scenario-file example_project.json', type: String
+
+          opt :reopt_scenario_file, "\nCreate a ScenarioFile that includes a column defining the REopt assumptions file\n" \
+          "Specify the existing ScenarioFile that you want to extend with REopt functionality\n" \
+          'Example: uo create --reopt-scenario-file baseline_scenario.csv', type: String
+        end
       end
 
-      opts.on('-o', '--overwrite_project_folder', String, "Use with -p argument to overwrite existing project folder and replace with new project folder.\n" \
-          "                                     Or use with -e and -p argument to overwrite existing project folder and replace with new empty project folder.\n" \
-          "                                     Usage: uo -o -p <DIR>\n" \
-          "                                     or uo -o -e -p <DIR>\n" \
-          "                                     Where <DIR> is the existing project folder\n\n") do
-        @user_input[:overwrite_project_folder] = 'Overwriting existing project folder' # This text does not get displayed to the user
-      end
+      # Define running commands
+      def opt_run
+        cmd = @command
+        @subopts = Optimist.options do
+          banner "\nURBANopt #{cmd}:\n \n"
 
-      opts.on('-m', '--make_scenario', String, "Create ScenarioCSV files for each MapperFile using the Feature file path. Must specify -f argument\n" \
-          "                                     Example: uo -m -f example_project.json\n" \
-          "                                     Or, Create Scenario CSV for each MapperFile for a single Feature from Feature File. Must specify -f and -i argument\n" \
-          "                                     Example: uo -m -f example_project.json -i 1\n\n") do
-        @user_input[:make_scenario_from] = "Create scenario files from FeatureFiles or for single Feature according to the MapperFiles in the 'mappers' directory" # This text does not get displayed to the user
-      end
+          opt :reopt, "\nSimulate with additional REopt functionality. Must do this before post-processing with REopt"
 
-      opts.on('-r', '--run', String, "Run simulations. Must specify -s & -f arguments\n" \
-          "                                     Example: uo -r -s baseline_scenario.csv -f example_project.json\n\n") do
-        @user_input[:run_scenario] = 'Run simulations' # This text does not get displayed to the user
-      end
+          opt :scenario, "\nRun URBANopt simulations for <scenario>\n" \
+          "Requires --feature also be specified\n" \
+          'Example: uo run --scenario baseline_scenario-2.csv --feature example_project.jsonn', default: 'baseline_scenario.csv', required: true
 
-      opts.on('-g', '--gather', String, "group individual feature results to scenario-level results. Must specify -t, -s, & -f arguments\n" \
-          "                                     Example: uo -g -t default -s baseline_scenario.csv -f example_project.json\n\n") do
-        @user_input[:gather] = 'Aggregate all features to a whole Scenario' # This text does not get displayed to the user
+          opt :feature, "\nRun URBANopt simulations according to <featurefile>\n" \
+          "Requires --scenario also be specified\n" \
+          'Example: uo run --scenario baseline_scenario.csv --feature example_project.json', default: 'example_project.json', required: true
+        end
       end
 
-      opts.on('-d', '--delete_scenario', String, "Delete results from scenario. Must specify -s argument\n" \
-          "                                     Example: uo -d -s baseline_scenario.csv\n\n") do
-        @user_input[:delete_scenario] = 'Delete scenario results that were created from <SFP>' # This text does not get displayed to the user
-      end
+      # Define post-processing commands
+      def opt_process
+        cmd = @command
+        @subopts = Optimist.options do
+          banner "\nURBANopt #{cmd}:\n \n"
 
-      opts.on('-s', '--scenario_file <SFP>', String, "Specify <SFP> (ScenarioCSV file path). Used as input for other commands\n\n") do |scenario|
-        @user_input[:scenario] = scenario
-        @root_dir, @scenario_file_name = File.split(File.absolute_path(@user_input[:scenario]))
-      end
+          opt :default, "\nStandard post-processing for your scenario"
 
-      opts.on('-f', '--feature_file <FFP>', String, "Specify <FFP> (Feature file path). Used as input for other commands\n\n") do |feature|
-        @user_input[:feature] = feature
-        @feature_path, @feature_name = File.split(File.absolute_path(@user_input[:feature]))
-      end
+          opt :opendss, "\nPost-process with OpenDSS"
 
-      opts.on('-i', '--feature_id <FID>', Integer, "Specify <FID> (Feature ID). Used as input for other commands\n\n") do |feature_id|
-        @user_input[:feature_id] = feature_id
-      end
+          opt :reopt_scenario, "\nOptimize for entire scenario with REopt\n" \
+          'Example: uo process --reopt-scenario'
+
+          opt :reopt_feature, "\nOptimize for each building individually with REopt\n" \
+          'Example: uo process --reopt-feature'
 
-      opts.on('-t', '--type <TYPE>', String, "Specify <TYPE> of post-processor to run:\n" \
-          "                                       default\n" \
-          "                                       reopt-scenario\n" \
-          "                                       reopt-feature\n" \
-          "                                       opendss\n\n") do |type|
-        @user_input[:type] = type
+          opt :scenario, "\nSelect which scenario to optimize", default: 'baseline_scenario.csv', required: true
+
+          opt :feature, "\nSelect which FeatureFile to use", default: 'example_project.json', required: true
+        end
       end
 
-      opts.on('-v', '--version', "Show CLI version and exit\n") do
-        @user_input[:version_request] = VERSION
+      def opt_delete
+        cmd = @command
+        @subopts = Optimist.options do
+          banner "\nURBANopt #{cmd}:\n \n"
+
+          opt :scenario, "\nDelete simulation files for this scenario", default: 'baseline_scenario.csv', required: true
+        end
       end
+
+      attr_reader :mainopts, :command, :subopts
     end
 
-    begin
-      the_parser.parse!
-    rescue OptionParser::InvalidOption => e
-      puts e
+    # Initialize the CLI class
+    @opthash = UrbanOptCLI.new
+
+    # Pull out feature and scenario filenames and paths
+    if @opthash.subopts[:scenario_file]
+      @feature_path, @feature_name = File.split(File.absolute_path(@opthash.subopts[:scenario_file]))
+    end
+    # FIXME: Can this be combined with the above block? This isn't very DRY
+    # One solution would be changing scenario_file to feature.
+    #   Would that be confusing when creating a ScenarioFile from the FeatureFile?
+    if @opthash.subopts[:feature]
+      @feature_path, @feature_name = File.split(File.absolute_path(@opthash.subopts[:feature]))
+    end
+    if @opthash.subopts[:scenario]
+      @root_dir, @scenario_file_name = File.split(File.absolute_path(@opthash.subopts[:scenario]))
     end
 
     # Simulate energy usage as defined by ScenarioCSV\
@@ -154,7 +202,11 @@ module URBANopt
       end
 
       feature_file = URBANopt::GeoJSON::GeoFile.from_file(featurefile)
-      scenario_output = URBANopt::Scenario::REoptScenarioCSV.new(name, @root_dir, run_dir, feature_file, mapper_files_dir, csv_file, num_header_rows, reopt_files_dir, reopt_assumptions_filename)
+      if @opthash.subopts[:reopt] == true || @opthash.subopts[:reopt_scenario] == true || @opthash.subopts[:reopt_feature] == true
+        scenario_output = URBANopt::Scenario::REoptScenarioCSV.new(name, @root_dir, run_dir, feature_file, mapper_files_dir, csv_file, num_header_rows, reopt_files_dir, reopt_assumptions_filename)
+      else
+        scenario_output = URBANopt::Scenario::ScenarioCSV.new(name, @root_dir, run_dir, feature_file, mapper_files_dir, csv_file, num_header_rows)
+      end
       scenario_output
     end
 
@@ -162,7 +214,7 @@ module URBANopt
     # params\
     # +feature_file_path+:: _string_ Path to a FeatureFile
     def self.create_scenario_csv_file(feature_id)
-      feature_file_json = JSON.parse(File.read(File.absolute_path(@user_input[:feature])), symbolize_names: true)
+      feature_file_json = JSON.parse(File.read(File.absolute_path(@opthash.subopts[:scenario_file])), symbolize_names: true)
       Dir["#{@feature_path}/mappers/*.rb"].each do |mapper_file|
         mapper_name = File.basename(mapper_file, File.extname(mapper_file))
         scenario_file_name = if feature_id == 'SKIP'
@@ -171,15 +223,15 @@ module URBANopt
                                "#{mapper_name.downcase}_scenario-#{feature_id}.csv"
                              end
         CSV.open(File.join(@feature_path, scenario_file_name), 'wb', write_headers: true,
-                                                                     headers: ['Feature Id', 'Feature Name', 'Mapper Class', 'REopt Assumptions']) do |csv|
+                                                                     headers: ['Feature Id', 'Feature Name', 'Mapper Class']) do |csv|
           feature_file_json[:features].each do |feature|
             if feature_id == 'SKIP'
               # ensure that feature is a building
               if feature[:properties][:type] == 'Building'
-                csv << [feature[:properties][:id], feature[:properties][:name], "URBANopt::Scenario::#{mapper_name}Mapper", 'multiPV_assumptions.json']
+                csv << [feature[:properties][:id], feature[:properties][:name], "URBANopt::Scenario::#{mapper_name}Mapper"]
               end
-            elsif feature_id == feature[:properties][:id].to_i
-              csv << [feature[:properties][:id], feature[:properties][:name], "URBANopt::Scenario::#{mapper_name}Mapper", 'multiPV_assumptions.json']
+            elsif feature_id == feature[:properties][:id]
+              csv << [feature[:properties][:id], feature[:properties][:name], "URBANopt::Scenario::#{mapper_name}Mapper"]
             elsif
               # If Feature ID specified does not exist in the Feature File raise error
               unless feature_file_json[:features].any? { |hash| hash[:properties][:id].include?(feature_id.to_s) }
@@ -191,12 +243,28 @@ module URBANopt
       end
     end
 
+    # Write new ScenarioFile with REopt column
+    # params \
+    # +existing_scenario_file+:: _string_ - Name of existing ScenarioFile
+    def self.create_reopt_scenario_file(existing_scenario_file)
+      existing_path, existing_name = File.split(File.absolute_path(existing_scenario_file))
+      table = CSV.read(existing_scenario_file, headers: true, col_sep: ',')
+      # Add another column, row by row:
+      table.each do |row|
+        row['REopt Assumptions'] = 'multiPV_assumptions.json'
+      end
+      # write new file
+      CSV.open(File.join(existing_path, 'REopt_scenario.csv'), 'w') do |f|
+        f << table.headers
+        table.each { |row| f << row }
+      end
+    end
+
     # Create project folder
     # params\
     # +dir_name+:: _string_ Name of new project folder
     #
-    # Folder gets created in the current working directory
-    # Includes weather for UO's example location, a base workflow file, and mapper files to show a baseline and a high-efficiency option.
+    # Includes weather for example location, a base workflow file, and mapper files to show a baseline and a high-efficiency option.
     def self.create_project_folder(dir_name, empty_folder = false, overwrite_project = false)
       if overwrite_project == true
         if Dir.exist?(dir_name)
@@ -219,7 +287,8 @@ module URBANopt
 
       config_file = 'https://raw.githubusercontent.com/urbanopt/urbanopt-cli/master/example_files/runner.conf'
       example_feature_file = 'https://raw.githubusercontent.com/urbanopt/urbanopt-cli/master/example_files/example_project.json'
-      example_gem_file = 'https://raw.githubusercontent.com/urbanopt/urbanopt-cli/master/example_files/Gemfile'
+      # FIXME: Gemfile is TEMPORARILY pointint to branch. Restore to master before merging to master.
+      example_gem_file = 'https://raw.githubusercontent.com/urbanopt/urbanopt-cli/openstudio-3.x/example_files/Gemfile'
       remote_weather_files = [
         'https://raw.githubusercontent.com/urbanopt/urbanopt-cli/master/example_files/weather/USA_NY_Buffalo-Greater.Buffalo.Intl.AP.725280_TMY3.epw',
         'https://raw.githubusercontent.com/urbanopt/urbanopt-cli/master/example_files/weather/USA_NY_Buffalo-Greater.Buffalo.Intl.AP.725280_TMY3.ddy',
@@ -294,97 +363,82 @@ module URBANopt
     end
 
     # Perform CLI actions
-    if @user_input[:project_folder] && @user_input[:empty_project_folder].nil?
-      if @user_input[:overwrite_project_folder]
-        puts "\nOverwriting existing project folder: #{@user_input[:project_folder]}...\n\n"
-        puts "Creating a new project folder...\n"
-        create_project_folder(@user_input[:project_folder], empty_folder = false, overwrite_project = true)
-      elsif @user_input[:overwrite_project_folder].nil?
-        create_project_folder(@user_input[:project_folder], empty_folder = false, overwrite_project = false)
+
+    # Create new project folder
+    if @opthash.command == 'create' && @opthash.subopts[:project_folder] && @opthash.subopts[:empty] == false
+      if @opthash.subopts[:overwrite] == true
+        puts "\nOverwriting existing project folder: #{@opthash.subopts[:project_folder]}...\n\n"
+        create_project_folder(@opthash.subopts[:project_folder], empty_folder = false, overwrite_project = true)
+      elsif @opthash.subopts[:overwrite] == false
+        puts "\nCreating a new project folder...\n"
+        create_project_folder(@opthash.subopts[:project_folder], empty_folder = false, overwrite_project = false)
       end
       puts "\nAn example FeatureFile is included: 'example_project.json'. You may place your own FeatureFile alongside the example."
       puts 'Weather data is provided for the example FeatureFile. Additional weather data files may be downloaded from energyplus.net/weather for free'
       puts "If you use additional weather files, ensure they are added to the 'weather' directory. You will need to configure your mapper file and your osw file to use the desired weather file"
-      puts "Next, create ScenarioFiles using this CLI call: 'uo -m -f <FFP>'\n"
       puts "We recommend using absolute paths for all commands, for cleaner output\n"
-    elsif @user_input[:project_folder] && @user_input[:empty_project_folder]
-      if @user_input[:overwrite_project_folder]
-        puts "\nOverwriting existing project folder: #{@user_input[:project_folder]}...\n\n"
-        puts "Creating a new project folder...\n\n"
-        create_project_folder(@user_input[:project_folder], empty_folder = true, overwrite_project = true)
-      elsif @user_input[:overwrite_project].nil?
-        create_project_folder(@user_input[:project_folder], empty_folder = true, overwrite_project = false)
+    elsif @opthash.command == 'create' && @opthash.subopts[:project_folder] && @opthash.subopts[:empty] == true
+      if @opthash.subopts[:overwrite] == true
+        puts "\nOverwriting existing project folder: #{@opthash.subopts[:project_folder]} with an empty folder...\n\n"
+        create_project_folder(@opthash.subopts[:project_folder], empty_folder = true, overwrite_project = true)
+      elsif @opthash.subopts[:overwrite] == false
+        puts "\nCreating a new empty project folder...\n"
+        create_project_folder(@opthash.subopts[:project_folder], empty_folder = true, overwrite_project = false)
       end
-      puts 'Add your FeatureFile in the Project directory you just created.'
+      puts "\nAdd your FeatureFile in the Project directory you just created."
       puts 'Add your weather data files in the Weather folder. They may be downloaded from energyplus.net/weather for free'
       puts 'Add your OpenStudio models for Features in your Feature file, if any in the osm_building folder'
-      puts "Next, create ScenarioFiles using this CLI call: 'uo -m -f <FFP>'\n"
       puts "We recommend using absolute paths for all commands, for cleaner output\n"
     end
 
-    if @user_input[:make_scenario_from]
-      if @user_input[:feature].nil?
-        abort("\nYou must provide the '-f' flag and a valid path to a FeatureFile!\n---\n\n")
-      end
-
-      if @user_input[:feature_id]
-        puts "\nBuilding sample ScenarioFiles, assigning mapper classes to Feature ID #{@user_input[:feature_id]}..."
-        create_scenario_csv_file(@user_input[:feature_id])
+    # Create ScenarioFile from FeatureFile
+    if @opthash.command == 'create' && @opthash.subopts[:scenario_file]
+      if @opthash.subopts[:single_feature]
+        puts "\nBuilding sample ScenarioFiles, assigning mapper classes to Feature ID #{@opthash.subopts[:single_feature]}"
+        create_scenario_csv_file(@opthash.subopts[:single_feature])
         puts "\nDone\n"
       else
-        puts "\nBuilding sample ScenarioFiles, assigning mapper classes to each feature from #{@feature_name}..."
+        puts "\nBuilding sample ScenarioFiles, assigning mapper classes to each feature from #{@feature_name}"
         # Skip Feature ID argument if not present
         create_scenario_csv_file('SKIP')
         puts "\nDone\n"
       end
     end
 
-    if @user_input[:run_scenario]
-      if @user_input[:scenario].nil?
-        abort("\nYou must provide '-s' flag and a valid path to a ScenarioFile!\n---\n\n")
-      end
-      if @user_input[:feature].nil?
-        abort("\nYou must provide '-f' flag and a valid path to a FeatureFile!\n---\n\n")
-      end
-      if @user_input[:scenario].to_s.include? '-'
+    # Create REopt ScenarioFile from existing
+    if @opthash.command == 'create' && @opthash.subopts[:reopt_scenario_file]
+      puts "\nCreating ScenarioFile with REopt functionality, extending from #{@opthash.subopts[:reopt_scenario_file]}..."
+      create_reopt_scenario_file(@opthash.subopts[:reopt_scenario_file])
+      puts "\nDone"
+    end
+
+    # Run simulations
+    if @opthash.command == 'run' && @opthash.subopts[:scenario] && @opthash.subopts[:feature]
+      if @opthash.subopts[:scenario].to_s.include? '-'
         @scenario_folder = @scenario_file_name.split(/\W+/)[0].capitalize.to_s
         @feature_id = (@feature_name.split(/\W+/)[1]).to_s
       else
         @scenario_folder = @scenario_file_name.split('.')[0].capitalize.to_s
       end
-      puts "\nSimulating features of '#{@feature_name}' as directed by '#{@user_input[:scenario]}'...\n\n"
+      puts "\nSimulating features of '#{@feature_name}' as directed by '#{@scenario_file_name}'...\n\n"
       scenario_runner = URBANopt::Scenario::ScenarioRunnerOSW.new
       scenario_runner.run(run_func)
       puts "\nDone\n"
     end
 
-    if @user_input[:gather]
-      if @user_input[:scenario].nil?
-        abort("\nYou must provide '-s' flag and a valid path to a ScenarioFile!\n---\n\n")
-      end
-      if @user_input[:feature].nil?
-        abort("\nYou must provide '-f' flag and a valid path to a FeatureFile!\n---\n\n")
+    # Post-process the scenario
+    if @opthash.command == 'process'
+      if @opthash.subopts[:default] == false && @opthash.subopts[:opendss] == false && @opthash.subopts[:reopt_scenario] == false && @opthash.subopts[:reopt_feature] == false
+        abort("\nERROR: No valid process type entered. Must enter a valid process type\n")
       end
-
-      valid_postprocessors = ['default', 'reopt-scenario', 'reopt-feature', 'opendss']
-      # Abort if <type> is nil or not in valid list
-      if @user_input[:type].nil? || valid_postprocessors.none? { |needle| @user_input[:type].include? needle }
-        abort("\nYou must provide '-t' flag and a valid Gather type!\n" \
-            "Valid types include: #{valid_postprocessors}\n---\n\n")
-      end
-
       @scenario_folder = @scenario_file_name.split('.')[0].capitalize.to_s
-
       default_post_processor = URBANopt::Scenario::ScenarioDefaultPostProcessor.new(run_func)
       scenario_report = default_post_processor.run
       scenario_report.save
-      # FIXME: Remove this feature_reports block once urbanopt/urbanopt-scenario-gem#104 works as expected.
-      # save feature reports
-      scenario_report.feature_reports.each(&:save_feature_report)
-
-      if @user_input[:type] == valid_postprocessors[0]
+      if @opthash.subopts[:default] == true
+        puts 'Post-processing URBANopt results'
         puts "\nDone\n"
-      elsif @user_input[:type] == valid_postprocessors[3]
+      elsif @opthash.subopts[:opendss] == true
         puts "\nPost-processing OpenDSS results\n"
         opendss_folder = File.join(@root_dir, 'run', @scenario_file_name.split('.')[0], 'opendss')
         if File.directory?(opendss_folder)
@@ -395,30 +449,23 @@ module URBANopt
         else
           abort("\nNo OpenDSS results available in folder '#{opendss_folder}'\n")
         end
-      elsif @user_input[:type].to_s.include?('reopt')
+      elsif @opthash.subopts.to_s.include?('reopt')
         scenario_base = default_post_processor.scenario_base
         reopt_post_processor = URBANopt::REopt::REoptPostProcessor.new(scenario_report, scenario_base.scenario_reopt_assumptions_file, scenario_base.reopt_feature_assumptions, DEVELOPER_NREL_KEY)
-
-        # Optimize REopt outputs for the whole Scenario
-        if @user_input[:type] == valid_postprocessors[1]
-          puts "\nOptimizing renewable energy for the scenario\n"
+        if @opthash.subopts[:reopt_scenario] == true
+          puts "\nPost-processing entire scenario with REopt\n"
           scenario_report_scenario = reopt_post_processor.run_scenario_report(scenario_report: scenario_report, save_name: 'scenario_optimization')
           puts "\nDone\n"
-        # Optimize REopt outputs for each feature individually
-        elsif @user_input[:type] == valid_postprocessors[2]
-          puts "\nOptimizing renewable energy for each feature\n"
+        elsif @opthash.subopts[:reopt_feature] == true
+          puts "\nPost-processing each building individually with REopt\n"
           scenario_report_features = reopt_post_processor.run_scenario_report_features(scenario_report: scenario_report, save_names_feature_reports: ['feature_optimization'] * scenario_report.feature_reports.length, save_name_scenario_report: 'feature_optimization')
           puts "\nDone\n"
         end
-      else
-        abort("\nError: did not use one of these valid types: #{valid_postprocessors} Aborting...\n---\n\n")
       end
     end
 
-    if @user_input[:delete_scenario]
-      if @user_input[:scenario].nil?
-        abort("\nYou must provide '-s' flag and a valid path to a ScenarioFile!\n---\n\n")
-      end
+    # Delete simulations from a scenario
+    if @opthash.command == 'delete'
       scenario_name = @scenario_file_name.split('.')[0]
       scenario_path = File.absolute_path(@root_dir)
       scenario_results_dir = File.join(scenario_path, 'run', scenario_name)
@@ -426,9 +473,5 @@ module URBANopt
       FileUtils.rm_rf(scenario_results_dir)
       puts "\nDone\n"
     end
-
-    if @user_input[:version_request]
-      puts "\nURBANopt CLI version: #{@user_input[:version_request]}\n---\n\n"
-    end
   end
 end

data/uo_cli.gemspec

@@ -29,19 +29,19 @@ Gem::Specification.new do |spec|
   # spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.executables = ['uo']
   spec.require_paths = ['lib']
-  spec.required_ruby_version = '~> 2.2.4'
+  spec.required_ruby_version = '~> 2.5.0'
 
   #   use specific versions of these dependencies while using Ruby 2.2
-  spec.add_development_dependency 'rack', '2.1.2'
+  #spec.add_development_dependency 'rack', '2.1.2'
 
   #   use specific versions of urbanopt and openstudio dependencies while under heavy development
-  spec.add_dependency 'urbanopt-geojson', '0.2.0'
-  spec.add_dependency 'urbanopt-reopt', '0.2.1'
-  spec.add_dependency 'urbanopt-scenario', '0.2.0'
+  spec.add_dependency 'optimist'
+  spec.add_dependency 'urbanopt-geojson', '0.3.0.pre1'
+  spec.add_dependency 'urbanopt-reopt', '0.3.0.pre1'
+  spec.add_dependency 'urbanopt-scenario', '0.3.0.pre1'
 
-  spec.add_development_dependency 'bundler', '~> 1.17'
-  spec.add_development_dependency 'github_api', '~> 0.18'
-  spec.add_development_dependency 'rake', '~> 12.3'
+  spec.add_development_dependency 'bundler', '~> 2.1'
+  spec.add_development_dependency 'rake', '~> 13.0'
   spec.add_development_dependency 'rspec', '~> 3.7'
   spec.add_development_dependency 'rubocop', '~> 0.54.0'
 end

metadata

@@ -1,113 +1,99 @@
 --- !ruby/object:Gem::Specification
 name: urbanopt-cli
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.3.0.pre1
 platform: ruby
 authors:
 - Nathan Moore
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-04-28 00:00:00.000000000 Z
+date: 2020-05-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: rack
+  name: optimist
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 2.1.2
-  type: :development
+        version: '0'
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 2.1.2
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: urbanopt-geojson
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.2.0
+        version: 0.3.0.pre1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.2.0
+        version: 0.3.0.pre1
 - !ruby/object:Gem::Dependency
   name: urbanopt-reopt
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.2.1
+        version: 0.3.0.pre1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.2.1
+        version: 0.3.0.pre1
 - !ruby/object:Gem::Dependency
   name: urbanopt-scenario
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.2.0
+        version: 0.3.0.pre1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.2.0
+        version: 0.3.0.pre1
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.17'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.17'
-- !ruby/object:Gem::Dependency
-  name: github_api
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.18'
+        version: '2.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.18'
+        version: '2.1'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '12.3'
+        version: '13.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '12.3'
+        version: '13.0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -193,15 +179,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - "~>"
     - !ruby/object:Gem::Version
-      version: 2.2.4
+      version: 2.5.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.4.5.1
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: URBANopt CLI