bcl 0.5.8 → 0.5.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 317f08f02e79fd41f98a711a6cff460d55125fd0
-  data.tar.gz: 3c29a18af6c83f742537e00a96f422f5e5dc8500
+  metadata.gz: e73294b8462def2d2ff8831ec1b3e334efcf47e4
+  data.tar.gz: 535c60ceb7b0095ec0fe6952d3b4ef0788c9b5d9
 SHA512:
-  metadata.gz: 9023fdac7c3cfbb86e8e38ac776eb2483b87123936c90785a62f98c00870dde73bafa3e0f1cd56f1cd415b357032921befaa9b81fd6b104689722f50ae53ca12
-  data.tar.gz: 98e2043d5d609d8a29cfc080c76d2269d836221e3a94c33e41102f85d57031882815abe747ceae0b73a341ee47f582df2c393ad0ca5e03f20cd5b2822ce4dbcf
+  metadata.gz: 8ebe642bcbf101803db171a0af1916a8bb9b4b883924bc07fd30c25c16614f34ef75733d333607eb1a511a1a70fcf5a8ec8ebae63c0893184f84d0059a54f1fd
+  data.tar.gz: 7f61168eb018bd9db461ecbd8f96fd0b17d86fe600deaa908e88a1b6675101fb21901322bed63e81710d469bd9df3d51e668a7f2e2f7552385eb5958e0049828

data/lib/bcl.rb

@@ -15,6 +15,7 @@ require 'multi_json'
 require 'builder'
 require 'uuid'
 require 'net/https'
+require 'rexml/document'
 
 # TODO: can we condense these into one?
 require 'archive/tar/minitar'
@@ -22,7 +23,7 @@ require 'zlib'
 require 'zip'
 
 # ability to write spreadsheets
-require 'rubyXL'
+require 'spreadsheet'
 
 require 'bcl/core_ext'
 require 'bcl/base_xml'

data/lib/bcl/base_xml.rb

@@ -1,5 +1,5 @@
 ######################################################################
-#  Copyright (c) 2008-2014, Alliance for Sustainable Energy.
+#  Copyright (c) 2008-2019, Alliance for Sustainable Energy.
 #  All rights reserved.
 #
 #  This library is free software; you can redistribute it and/or
@@ -17,6 +17,10 @@
 #  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 ######################################################################
 
+# KAF 2/13/2018
+# This functionality is being kept in case we need in to recreate weather files in the future
+# It is very out of date and would need a major reworking wrt to the updated schema
+
 module BCL
   ProvStruct = Struct.new(:author, :datetime, :comment)
   TagsStruct = Struct.new(:descriptor)
@@ -109,7 +113,7 @@ module BCL
     # return the title case of the string
     def tc(input)
       val = input.gsub(/\b\w/) { $&.upcase }
-      if val.downcase == 'energyplus'
+      if val.casecmp('energyplus').zero?
         val = 'EnergyPlus'
       end
 
@@ -133,9 +137,13 @@ module BCL
       # simple method to test if the input_value is a string, float, or integer.
       # First convert the value back to a string for testing (in case it was passed as a float/integer)
       test = input_value.to_s
-      input_value = test.match('\.').nil? ? Integer(test) : Float(test) rescue test.to_s
+      input_value = begin
+                      test.match('\.').nil? ? Integer(test) : Float(test)
+                    rescue StandardError
+                      test.to_s
+                    end
 
-      if input_value.is_a?(Fixnum) || input_value.is_a?(Bignum)
+      if input_value.is_a?(Integer) || input_value.is_a?(Integer)
         dt = 'int'
       elsif input_value.is_a?(Float)
         dt = 'float'

data/lib/bcl/component.rb

@@ -1,5 +1,5 @@
 ######################################################################
-#  Copyright (c) 2008-2014, Alliance for Sustainable Energy.
+#  Copyright (c) 2008-2019, Alliance for Sustainable Energy.
 #  All rights reserved.
 #
 #  This library is free software; you can redistribute it and/or
@@ -98,11 +98,11 @@ module BCL
       # take all the files and tar.gz them -- name the file the same as
       # the directory
 
-      Dir.chdir("#{resolve_path}")
-      destination = "#{@name.gsub(/\W/, '_').gsub(/___/, '_').gsub(/__/, '_').chomp('_').strip}"
+      Dir.chdir(resolve_path.to_s)
+      destination = @name.gsub(/\W/, '_').gsub(/___/, '_').gsub(/__/, '_').chomp('_').strip.to_s
       # truncate filenames for paths that are longer than 256 characters (with .tar.gz appended)
       unless (@path + destination + destination).size < 249
-        destination = "#{@uid}"
+        destination = @uid.to_s
         puts 'truncating filename...using uid instead of name'
       end
       destination += '.tar.gz'
@@ -126,7 +126,7 @@ module BCL
     end
 
     def add_cost(cost_name, cost_type, category, value, units, interval, interval_units, year, location, currency,
-             source, reference_component_name, reference_component_id)
+                 source, reference_component_name, reference_component_id)
       cs = CostStruct.new
       cs.cost_name = cost_name
       cs.cost_type = cost_type
@@ -284,7 +284,7 @@ module BCL
       # setup the xml file
       comp_xml.instruct! :xml, version: '1.0', encoding: 'UTF-8'
       comp_xml.component('xmlns:xsi' => 'http://www.w3.org/2001/XMLSchema-instance',
-                         'xsi:noNamespaceSchemaLocation' => "#{@schema_url}") do
+                         'xsi:noNamespaceSchemaLocation' => @schema_url.to_s) do
         comp_xml.name @name
         comp_xml.uid @uuid
         comp_xml.version_id @vuid

data/lib/bcl/component_from_spreadsheet.rb

@@ -1,5 +1,5 @@
 ######################################################################
-#  Copyright (c) 2008-2014, Alliance for Sustainable Energy.
+#  Copyright (c) 2008-2019, Alliance for Sustainable Energy.
 #  All rights reserved.
 #
 #  This library is free software; you can redistribute it and/or
@@ -19,7 +19,7 @@
 
 # Converts a custom Excel spreadsheet format to BCL components for upload
 
-require 'rubyXL'
+require 'spreadsheet'
 require 'bcl'
 
 module BCL
@@ -33,12 +33,13 @@ module BCL
     public
 
     # initialize with Excel spreadsheet to read
+    # seems to only be working with xls spreadsheets
     def initialize(xlsx_path, worksheet_names = ['all'])
       @xlsx_path = Pathname.new(xlsx_path).realpath.to_s
       @worksheets = []
 
       begin
-        xlsx = RubyXL::Parser.parse(@xlsx_path)
+        xlsx = Spreadsheet.open(@xlsx_path)
 
         # by default, operate on all worksheets
         if worksheet_names == ['all']
@@ -47,7 +48,7 @@ module BCL
           end
         else # if specific worksheets are specified, operate on them
           worksheet_names.each do |worksheet_name|
-            parse_xlsx_worksheet(xlsx[worksheet_name])
+            parse_xlsx_worksheet(xlsx.worksheet(worksheet_name))
           end
         end
 
@@ -82,6 +83,7 @@ module BCL
             if /description/i.match(header.name)
               name = values.delete_at(0) # name, uid already processed
               uid = values.delete_at(0)
+              component_xml.comp_version_id = values.delete_at(0)
               description = values.delete_at(0)
               component_xml.modeler_description = values.delete_at(0)
               component_xml.description = description
@@ -126,6 +128,7 @@ module BCL
               filepath = values.delete_at(0)
               # not all components(rows) have all files; skip if filename "" or nil
               next if filename == '' || filename.nil?
+
               # skip the file if it doesn't exist at the specified location
               unless File.exist?(filepath)
                 puts "[ComponentFromSpreadsheet] ERROR #{filepath} -> File does not exist, will not be included in component xml"
@@ -133,7 +136,7 @@ module BCL
               end
               component_xml.add_file(software_program, version, filepath, filename, filetype)
             else
-              fail "Unknown section #{header.name}"
+              raise "Unknown section #{header.name}"
             end
           end
 
@@ -148,15 +151,15 @@ module BCL
 
     def parse_xlsx_worksheet(xlsx_worksheet)
       worksheet = WorksheetStruct.new
-      worksheet.name = xlsx_worksheet[0][0].value # get A1, order is: row, col
+      worksheet.name = xlsx_worksheet.row(0)[0] # get A1, order is: row, col
       worksheet.components = []
       puts "[ComponentFromSpreadsheet] Starting parsing components of type #{worksheet.name}"
 
       # find number of rows, first column should be name, should not be empty
-
-      xlsx_data = xlsx_worksheet.extract_data
-      # puts "Data: #{xlsx_data.inspect}"
-      # puts "***********************"
+      xlsx_data = []
+      xlsx_worksheet.each do |ws|
+        xlsx_data << ws
+      end
 
       num_rows = xlsx_data.size
       puts "Number of Rows: #{xlsx_data.size}"

data/lib/bcl/component_methods.rb

@@ -1,5 +1,5 @@
 ######################################################################
-#  Copyright (c) 2008-2014, Alliance for Sustainable Energy.
+#  Copyright (c) 2008-2019, Alliance for Sustainable Energy.
 #  All rights reserved.
 #
 #  This library is free software; you can redistribute it and/or
@@ -38,7 +38,7 @@ module BCL
       load_config
     end
 
-     def login(username = nil, password = nil, url = nil, group_id = nil)
+    def login(username = nil, password = nil, url = nil, group_id = nil)
       # figure out what url to use
       if url.nil?
         url = @config[:server][:url]
@@ -53,7 +53,7 @@ module BCL
       url = url.gsub('http://', '')
       url = url.gsub('https://', '')
 
-      if username.nil? || passwrord.nil?
+      if username.nil? || password.nil?
         # log in via cached credentials
         username = @config[:server][:user][:username]
         password = @config[:server][:user][:password]
@@ -145,390 +145,6 @@ module BCL
       end
     end
 
-    # retrieve, parse, and save metadata for BCL measures
-    def measure_metadata(search_term = nil, filter_term = nil, return_all_pages = false)
-      # setup results directory
-      unless File.exist?(@parsed_measures_path)
-        FileUtils.mkdir_p(@parsed_measures_path)
-      end
-      puts "...storing parsed metadata in #{@parsed_measures_path}"
-
-      # retrieve measures
-      puts "retrieving measures that match search_term: #{search_term.nil? ? 'nil' : search_term} and filters: #{filter_term.nil? ? 'nil' : filter_term}"
-      measures = []
-      retrieve_measures(search_term, filter_term, return_all_pages) do |m|
-        begin
-          r = parse_measure_metadata(m)
-          measures << r if r
-        rescue => e
-          puts "[ERROR] Parsing measure #{e.message}:#{e.backtrace.join("\n")}"
-        end
-      end
-
-      measures
-    end
-
-    # Read in an existing measure.rb file and extract the arguments.
-    # TODO: deprecate the _measure_name. This is used in the openstudio analysis gem, so it has to be carefully removed or renamed
-    def parse_measure_file(_measure_name, measure_filename)
-      measure_hash = {}
-
-      if File.exist? measure_filename
-        # read in the measure file and extract some information
-        measure_string = File.read(measure_filename)
-
-        measure_hash[:classname] = measure_string.match(/class (.*) </)[1]
-        measure_hash[:name] = measure_hash[:classname].to_underscore
-        measure_hash[:display_name] = nil
-        measure_hash[:display_name_titleized] = measure_hash[:name].titleize
-        measure_hash[:display_name_from_measure] = nil
-
-        if measure_string =~ /OpenStudio::Ruleset::WorkspaceUserScript/
-          measure_hash[:measure_type] = 'EnergyPlusMeasure'
-        elsif measure_string =~ /OpenStudio::Ruleset::ModelUserScript/
-          measure_hash[:measure_type] = 'RubyMeasure'
-        elsif measure_string =~ /OpenStudio::Ruleset::ReportingUserScript/
-          measure_hash[:measure_type] = 'ReportingMeasure'
-        elsif measure_string =~ /OpenStudio::Ruleset::UtilityUserScript/
-          measure_hash[:measure_type] = 'UtilityUserScript'
-        else
-          fail "measure type is unknown with an inherited class in #{measure_filename}: #{measure_hash.inspect}"
-        end
-
-        # New versions of measures have name, description, and modeler description methods
-        n = measure_string.scan(/def name(.*?)end/m).first
-        if n
-          n = n.first.strip
-          n.gsub!('return', '')
-          n.gsub!(/"|'/, '')
-          n.strip!
-          measure_hash[:display_name_from_measure] = n
-        end
-
-        # New versions of measures have name, description, and modeler description methods
-        n = measure_string.scan(/def description(.*?)end/m).first
-        if n
-          n = n.first.strip
-          n.gsub!('return', '')
-          n.gsub!(/"|'/, '')
-          n.strip!
-          measure_hash[:description] = n
-        end
-
-        # New versions of measures have name, description, and modeler description methods
-        n = measure_string.scan(/def modeler_description(.*?)end/m).first
-        if n
-          n = n.first.strip
-          n.gsub!('return', '')
-          n.gsub!(/"|'/, '')
-          n.strip!
-          measure_hash[:modeler_description] = n
-        end
-
-        measure_hash[:arguments] = []
-
-        args = measure_string.scan(/(.*).*=.*OpenStudio::Ruleset::OSArgument.*make(.*)Argument\((.*).*\)/)
-        args.each do |arg|
-          new_arg = {}
-          new_arg[:name] = nil
-          new_arg[:display_name] = nil
-          new_arg[:variable_type] = nil
-          new_arg[:local_variable] = nil
-          new_arg[:units] = nil
-          new_arg[:units_in_name] = nil
-
-          new_arg[:local_variable] = arg[0].strip
-          new_arg[:variable_type] = arg[1]
-          arg_params = arg[2].split(',')
-          new_arg[:name] = arg_params[0].gsub(/"|'/, '')
-          next if new_arg[:name] == 'info_widget'
-          choice_vector = arg_params[1] ? arg_params[1].strip : nil
-
-          # try find the display name of the argument
-          reg = /#{new_arg[:local_variable]}.setDisplayName\((.*)\)/
-          if measure_string =~ reg
-            new_arg[:display_name] = measure_string.match(reg)[1]
-            new_arg[:display_name].gsub!(/"|'/, '') if new_arg[:display_name]
-          else
-            new_arg[:display_name] = new_arg[:name]
-          end
-
-          p = parse_measure_name(new_arg[:display_name])
-          new_arg[:display_name] = p[0]
-          new_arg[:units_in_name] = p[1]
-
-          # try to get the units
-          reg = /#{new_arg[:local_variable]}.setUnits\((.*)\)/
-          if measure_string =~ reg
-            new_arg[:units] = measure_string.match(reg)[1]
-            new_arg[:units].gsub!(/"|'/, '') if new_arg[:units]
-          end
-
-          if measure_string =~ /#{new_arg[:local_variable]}.setDefaultValue/
-            new_arg[:default_value] = measure_string.match(/#{new_arg[:local_variable]}.setDefaultValue\((.*)\)/)[1]
-          else
-            puts "[WARNING] #{measure_hash[:name]}:#{new_arg[:name]} has no default value... will continue"
-          end
-
-          case new_arg[:variable_type]
-            when 'Choice'
-              # Choices to appear to only be strings?
-              # puts "Choice vector appears to be #{choice_vector}"
-              new_arg[:default_value].gsub!(/"|'/, '') if new_arg[:default_value]
-
-              # parse the choices from the measure
-              # scan from where the "instance has been created to the measure"
-              possible_choices = nil
-              possible_choice_block = measure_string # .scan(/#{choice_vector}.*=(.*)#{new_arg[:local_variable]}.*=/mi)
-              if possible_choice_block
-                # puts "possible_choice_block is #{possible_choice_block}"
-                possible_choices = possible_choice_block.scan(/#{choice_vector}.*<<.*(')(.*)(')/)
-                possible_choices += possible_choice_block.scan(/#{choice_vector}.*<<.*(")(.*)(")/)
-              end
-
-              # puts "Possible choices are #{possible_choices}"
-
-              if possible_choices.nil? || possible_choices.empty?
-                new_arg[:choices] = []
-              else
-                new_arg[:choices] = possible_choices.map { |c| c[1] }
-              end
-
-              # if the choices are inherited from the model, then need to just display the default value which
-              # somehow magically works because that is the display name
-              if new_arg[:default_value]
-                new_arg[:choices] << new_arg[:default_value] unless new_arg[:choices].include?(new_arg[:default_value])
-              end
-            when 'String', 'Path'
-              new_arg[:default_value].gsub!(/"|'/, '') if new_arg[:default_value]
-            when 'Bool'
-              if new_arg[:default_value]
-                new_arg[:default_value] = new_arg[:default_value].downcase == 'true' ? true : false
-              end
-            when 'Integer'
-              new_arg[:default_value] = new_arg[:default_value].to_i if new_arg[:default_value]
-            when 'Double'
-              new_arg[:default_value] = new_arg[:default_value].to_f if new_arg[:default_value]
-            else
-              fail "unknown variable type of #{new_arg[:variable_type]}"
-          end
-
-          measure_hash[:arguments] << new_arg
-        end
-      end
-
-      # check if there is a measure.xml file?
-      measure_xml_filename = "#{File.join(File.dirname(measure_filename), File.basename(measure_filename, '.*'))}.xml"
-      if File.exist? measure_xml_filename
-        f = File.open measure_xml_filename
-        doc = Nokogiri::XML(f)
-
-        # pull out some information
-        measure_hash[:name_xml] = doc.xpath('/measure/name').first.content
-        measure_hash[:uid] = doc.xpath('/measure/uid').first.content
-        measure_hash[:version_id] = doc.xpath('/measure/version_id').first.content
-        measure_hash[:tags] = doc.xpath('/measure/tags/tag').map(&:content)
-
-        measure_hash[:modeler_description_xml] = doc.xpath('/measure/modeler_description').first.content
-
-        measure_hash[:description_xml] = doc.xpath('/measure/description').first.content
-
-        f.close
-      end
-
-      # validate the measure information
-
-      validate_measure_hash(measure_hash)
-
-      measure_hash
-    end
-
-    # Validate the measure hash to make sure that it is meets the style guide. This will also perform the selection
-    # of which data to use for the "actual metadata"
-    #
-    # @param h [Hash] Measure hash
-    def validate_measure_hash(h)
-      if h.key? :name_xml
-        if h[:name_xml] != h[:name]
-          puts "[ERROR] {Validation}. Snake-cased name and the name in the XML do not match. Will default to automatic snake-cased measure name. #{h[:name_xml]} <> #{h[:name]}"
-        end
-      end
-
-      puts '[WARNING] {Validation} Could not find measure description in measure.'  unless h[:description]
-      puts '[WARNING] {Validation} Could not find modeler description in measure.'  unless h[:modeler_description]
-      puts '[WARNING] {Validation} Could not find measure name method in measure.'  unless h[:name_from_measure]
-
-      # check the naming conventions
-      if h[:display_name_from_measure]
-        if h[:display_name_from_measure] != h[:display_name_titleized]
-          puts '[WARNING] {Validation} Display name from measure and automated naming do not match. Will default to the automated name until all measures use the name method because of potential conflicts due to bad copy/pasting.'
-        end
-        h[:display_name] = h.delete :display_name_titleized
-      else
-        h[:display_name] = h.delete :display_name_titleized
-      end
-      h.delete :display_name_from_measure
-
-      if h.key?(:description) && h.key?(:description_xml)
-        if h[:description] != h[:description_xml]
-          puts '[ERROR] {Validation} Measure description and XML description differ. Will default to description in measure'
-        end
-        h.delete(:description_xml)
-      end
-
-      if h.key?(:modeler_description) && h.key?(:modeler_description_xml)
-        if h[:modeler_description] != h[:modeler_description_xml]
-          puts '[ERROR] {Validation} Measure modeler description and XML modeler description differ. Will default to modeler description in measure'
-        end
-        h.delete(:modeler_description_xml)
-      end
-
-      h[:arguments].each do |arg|
-        if arg[:units_in_name]
-          puts "[ERROR] {Validation} It appears that units are embedded in the argument name for #{arg[:name]}."
-
-          if arg[:units]
-            if arg[:units] != arg[:units_in_name]
-              puts '[ERROR] {Validation} Units in argument name do not match units in setUnits method. Using setUnits.'
-              arg.delete :units_in_name
-            end
-          else
-            puts '[ERROR] {Validation} Units appear to be in measure name. Please use setUnits.'
-            arg[:units] = arg.delete :units_in_name
-          end
-        else
-          # make sure to delete if null
-          arg.delete :units_in_name
-        end
-      end
-    end
-
-    def translate_measure_hash_to_csv(measure_hash)
-      csv = []
-      csv << [false, measure_hash[:display_name], measure_hash[:classname], measure_hash[:classname], measure_hash[:measure_type]]
-
-      measure_hash[:arguments].each do |argument|
-        values = []
-        values << ''
-        values << 'argument'
-        values << ''
-        values << argument[:display_name]
-        values << argument[:name]
-        values << argument[:display_name] # this is the default short display name
-        values << argument[:variable_type]
-        values << argument[:units]
-
-        # watch out because :default_value can be a boolean
-        argument[:default_value].nil? ? values << '' : values << argument[:default_value]
-        choices = ''
-        if argument[:choices]
-          choices << "|#{argument[:choices].join(',')}|" unless argument[:choices].empty?
-        end
-        values << choices
-
-        csv << values
-      end
-
-      csv
-    end
-
-    # Read the measure's information to pull out the metadata and to move into a more friendly directory name.
-    # argument of measure is a hash
-    def parse_measure_metadata(measure)
-      m_result = nil
-      # check for valid measure
-      if measure[:measure][:name] && measure[:measure][:uuid]
-
-        file_data = download_component(measure[:measure][:uuid])
-
-        if file_data
-          save_file = File.expand_path("#{@parsed_measures_path}/#{measure[:measure][:name].downcase.gsub(' ', '_')}.zip")
-          File.open(save_file, 'wb') { |f| f << file_data }
-
-          # unzip file and delete zip.
-          # TODO: check that something was downloaded here before extracting zip
-          if File.exist? save_file
-            BCL.extract_zip(save_file, @parsed_measures_path, true)
-
-            # catch a weird case where there is an extra space in an unzip file structure but not in the measure.name
-            if measure[:measure][:name] == 'Add Daylight Sensor at Center of Spaces with a Specified Space Type Assigned'
-              unless File.exist? "#{@parsed_measures_path}/#{measure[:measure][:name]}"
-                temp_dir_name = "#{@parsed_measures_path}/Add Daylight Sensor at Center of  Spaces with a Specified Space Type Assigned"
-                FileUtils.move(temp_dir_name, "#{@parsed_measures_path}/#{measure[:measure][:name]}")
-              end
-            end
-
-            temp_dir_name = File.join(@parsed_measures_path, measure[:measure][:name])
-
-            # Read the measure.rb file
-            # puts "save dir name #{temp_dir_name}"
-            measure_filename = "#{temp_dir_name}/measure.rb"
-            measure_hash = parse_measure_file(nil, measure_filename)
-
-            if measure_hash.empty?
-              puts 'Measure Hash was empty... moving on'
-            else
-              # puts measure_hash.inspect
-              m_result = measure_hash
-              # move the directory to the class name
-              new_dir_name = File.join(@parsed_measures_path, measure_hash[:classname])
-              # puts "Moving #{temp_dir_name} to #{new_dir_name}"
-              if temp_dir_name == new_dir_name
-                puts 'Destination directory is the same as the processed directory'
-              else
-                FileUtils.rm_rf(new_dir_name) if File.exist?(new_dir_name) && temp_dir_name != measure_hash[:classname]
-                FileUtils.move(temp_dir_name, new_dir_name) unless temp_dir_name == measure_hash[:classname]
-              end
-              # create a new measure.json file for parsing later if need be
-              File.open(File.join(new_dir_name, 'measure.json'), 'w') { |f| f << MultiJson.dump(measure_hash, pretty: true) }
-            end
-          else
-            puts "Problems downloading #{measure[:measure][:name]}... moving on"
-          end
-        end
-      end
-
-      m_result
-    end
-
-    # parse measure name
-    def parse_measure_name(name)
-      # TODO: save/display errors
-      errors = ''
-      m = nil
-
-      clean_name = name
-      units = nil
-
-      # remove everything btw parentheses
-      m = clean_name.match(/\((.+?)\)/)
-      unless m.nil?
-        errors += ' removing parentheses,'
-        units = m[1]
-        clean_name = clean_name.gsub(/\((.+?)\)/, '')
-      end
-
-      # remove everything btw brackets
-      m = nil
-      m = clean_name.match(/\[(.+?)\]/)
-      unless m.nil?
-        errors += ' removing brackets,'
-        clean_name = clean_name.gsub(/\[(.+?)\]/, '')
-      end
-
-      # remove characters
-      m = nil
-      m = clean_name.match(/(\?|\.|\#).+?/)
-      unless m.nil?
-        errors += ' removing any of following: ?.#'
-        clean_name = clean_name.gsub(/(\?|\.|\#).+?/, '')
-      end
-      clean_name = clean_name.gsub('.', '')
-      clean_name = clean_name.gsub('?', '')
-
-      [clean_name.strip, units]
-    end
-
     # retrieve measures for parsing metadata.
     # specify a search term to narrow down search or leave nil to retrieve all
     # set all_pages to true to iterate over all pages of results
@@ -560,7 +176,7 @@ module BCL
       result = { error: 'could not get json from http post response' }
       case api_response.code
         when '200'
-          puts "  Response Code: #{api_response.code} - #{api_response.body}"
+          puts "  Response Code: #{api_response.code}"
           if api_response.body.empty?
             puts '  200 BUT ERROR: Returned body was empty. Possible causes:'
             puts '      - BSD tar on Mac OSX vs gnutar'
@@ -572,23 +188,31 @@ module BCL
             valid = true
           end
         when '404'
-          puts "  Response: #{api_response.code} - #{api_response.body}"
-          puts '  404 - check these common causes first:'
-          puts '    - the filename contains periods (other than the ones before the file extension)'
-          puts "    - you are not an 'administrator member' of the group you're trying to upload to"
+          puts "  Error Code: #{api_response.code} - #{api_response.body}"
+          puts '   - check these common causes first:'
+          puts "     - you are trying to update content that doesn't exist"
+          puts "     - you are not an 'administrator member' of the group you're trying to upload to"
           result = MultiJson.load api_response.body
           valid = false
         when '406'
-          puts "  Response: #{api_response.code} - #{api_response.body}"
-          puts '  406 - check these common causes first:'
-          puts '    - the UUID of the item that you are uploading is already on the BCL'
-          puts '    - the group_id is not correct in the config.yml (go to group on site, and copy the number at the end of the URL)'
-          puts "    - you are not an 'administrator member' of the group you're trying to upload to"
-          result = MultiJson.load api_response.body
+          puts "  Error Code: #{api_response.code}"
+          # try to parse the response a bit
+          error = MultiJson.load api_response.body
+          puts "temp error: #{error}"
+          if error.key?('form_errors')
+            if error['form_errors'].key?('field_tar_file')
+              result = { error: error['form_errors']['field_tar_file'] }
+            elsif error['form_errors'].key?('og_group_ref][und][0][default')
+              result = { error: error['form_errors']['og_group_ref][und][0][default'] }
+            end
+          else
+            result = error
+          end
           valid = false
         when '500'
-          puts "  Response: #{api_response.code} - #{api_response.body}"
-          fail 'server exception'
+          puts "  Error Code: #{api_response.code}"
+          result = { error: api_response.message }
+          # fail 'server exception'
           valid = false
         else
           puts "  Response: #{api_response.code} - #{api_response.body}"
@@ -635,8 +259,8 @@ module BCL
     # pushes component to the bcl and publishes them (if logged-in as BCL Website Admin user).
     # username, password, and group_id are set in the ~/.bcl/config.yml file
     def push_content(filename_and_path, write_receipt_file, content_type)
-      fail 'Please login before pushing components' if @session.nil?
-      fail 'Do not have a valid access token; try again' if @access_token.nil?
+      raise 'Please login before pushing components' if @session.nil?
+      raise 'Do not have a valid access token; try again' if @access_token.nil?
 
       data = construct_post_data(filename_and_path, false, content_type)
 
@@ -663,7 +287,7 @@ module BCL
     # pushes updated content to the bcl and publishes it (if logged-in as BCL Website Admin user).
     # username and password set in ~/.bcl/config.yml file
     def update_content(filename_and_path, write_receipt_file, uuid = nil)
-      fail 'Please login before pushing components' unless @session
+      raise 'Please login before pushing components' unless @session
 
       # get the UUID if zip or xml file
       version_id = nil
@@ -676,10 +300,10 @@ module BCL
       else
         # verify the uuid via regex
         unless uuid =~ /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/
-          fail "uuid of #{uuid} is invalid"
+          raise "uuid of #{uuid} is invalid"
         end
       end
-      fail 'Please pass in a tar.gz file or pass in the uuid' unless uuid
+      raise 'Please pass in a tar.gz file or pass in the uuid' unless uuid
 
       data = construct_post_data(filename_and_path, true, uuid)
 
@@ -728,26 +352,29 @@ module BCL
       uuid = nil
       vid = nil
 
-      fail "File does not exist #{path_to_tarball}" unless File.exist? path_to_tarball
+      raise "File does not exist #{path_to_tarball}" unless File.exist? path_to_tarball
+
       tgz = Zlib::GzipReader.open(path_to_tarball)
       Archive::Tar::Minitar::Reader.open(tgz).each do |entry|
         # If taring with tar zcf ameasure.tar.gz -C measure_dir .
         if entry.name =~ /^.{0,2}component.xml$/ || entry.name =~ /^.{0,2}measure.xml$/
-          xml_file = Nokogiri::XML(entry.read)
+          # xml_to_parse = File.new( entry.read )
+          xml_file = REXML::Document.new entry.read
 
           # pull out some information
           if entry.name =~ /component/
-            u = xml_file.xpath('/component/uid').first
-            v = xml_file.xpath('/component/version_id').first
+            u = xml_file.elements['component/uid']
+            v = xml_file.elements['component/version_id']
           else
-            u = xml_file.xpath('/measure/uid').first
-            v = xml_file.xpath('/measure/version_id').first
+            u = xml_file.elements['measure/uid']
+            v = xml_file.elements['measure/version_id']
           end
-          fail "Could not find UUID in XML file #{path_to_tarball}" unless u
+          raise "Could not find UUID in XML file #{path_to_tarball}" unless u
+
           # Don't error on version not existing.
 
-          uuid = u.content
-          vid = v ? v.content : nil
+          uuid = u.text
+          vid = v ? v.text : nil
 
           # puts "uuid = #{uuid}; vid = #{vid}"
         end
@@ -756,6 +383,29 @@ module BCL
       [uuid, vid]
     end
 
+    def uuid_vid_from_xml(path_to_xml)
+      uuid = nil
+      vid = nil
+
+      raise "File does not exist #{path_to_xml}" unless File.exist? path_to_xml
+
+      xml_to_parse = File.new(path_to_xml)
+      xml_file = REXML::Document.new xml_to_parse
+
+      if path_to_xml.to_s.split('/').last =~ /component.xml/
+        u = xml_file.elements['component/uid']
+        v = xml_file.elements['component/version_id']
+      else
+        u = xml_file.elements['measure/uid']
+        v = xml_file.elements['measure/version_id']
+      end
+      raise "Could not find UUID in XML file #{path_to_tarball}" unless u
+
+      uuid = u.text
+      vid = v ? v.text : nil
+      [uuid, vid]
+    end
+
     def update_contents(array_of_tarball_components, skip_files_with_receipts)
       logs = []
       array_of_tarball_components.each do |comp|
@@ -781,6 +431,50 @@ module BCL
       logs
     end
 
+    def search_by_uuid(uuid, vid = nil)
+      full_url = '/api/search/*.json'
+      action = nil
+
+      # add api_version
+      if @api_version < 2.0
+        puts "WARNING:  attempting to use search with api_version #{@api_version}. Use API v2.0 for this functionality."
+      end
+      full_url += "?api_version=#{@api_version}"
+
+      # uuid
+      full_url += "&fq[]=ss_uuid:#{uuid}"
+      # puts "search url: #{full_url}"
+
+      res = @http.get(full_url)
+      res = MultiJson.load(res.body)
+
+      if res['result'].count > 0
+        # found content, check version
+        content = res['result'].first
+        # puts "first result: #{content}"
+
+        # parse out measure vs component
+        if content['measure']
+          content = content['measure']
+        else
+          content = content['component']
+        end
+
+        # TODO: check version_modified date if it exists?
+        if !vid.nil? && content['vuuid'] == vid
+          # no update needed
+          action = 'noop'
+        else
+          # vid doesn't match: update existing
+          action = 'update'
+        end
+      else
+        # no uuid found: push new
+        action = 'push'
+      end
+      action
+    end
+
     # Simple method to search bcl and return the result as hash with symbols
     # If all = true, iterate over pages of results and return all
     # JSON ONLY
@@ -883,12 +577,12 @@ module BCL
       # look at response code
       if result.code == '200'
         # puts 'Download Successful'
-        result.body ? result.body : nil
+        result.body || nil
       else
         puts "Download fail. Error code #{result.code}"
         nil
       end
-    rescue
+    rescue StandardError
       puts "Couldn't download uid(s): #{uid}...skipping"
       nil
     end
@@ -905,8 +599,10 @@ module BCL
         # location of template file
         FileUtils.mkdir_p(File.dirname(config_filename))
         File.open(config_filename, 'w') { |f| f << default_yaml.to_yaml }
-        File.chmod(0600, config_filename)
+        File.chmod(0o600, config_filename)
         puts "******** Please fill in user credentials in #{config_filename} file if you need to upload data **********"
+        # fill in the @config data with the temporary data for now.
+        @config = YAML.load_file(config_filename)
       end
     end