bcl 0.1.4 → 0.1.5

data/lib/bcl/MasterTaxonomy.rb

@@ -38,13 +38,19 @@ module BCL
 TagStruct = Struct.new(:level_hierarchy, :name, :description, :parent_tag, :child_tags, :terms)
 
 # each TermStruct represents a row in the master taxonomy
-TermStruct = Struct.new(:first_level, :second_level, :third_level, :level_hierarchy, :name, :description)
+TermStruct = Struct.new(:first_level, :second_level, :third_level, :level_hierarchy, :name, :description, 
+					    :abbr, :data_type, :enums, :ip_written, :ip_symbol, :ip_mask, :si_written, :si_symbol, :si_mask, :allow_multiple, :row, :tp_include, :tp_required, :tp_use_in_search, :tp_use_in_facets, :tp_hide_from_data_users, :tp_third_party_testing, :tp_additional_web_dev_info, :tp_additional_data_user_info, :tp_additional_data_submitter_info)
+
+						
+						
+						
 
 # class for parsing, validating, and querying the master taxonomy document
 class MasterTaxonomy
 
   # parse the master taxonomy document
-  def initialize(xlsx_path = nil)
+  def initialize(xlsx_path = nil, sort_alpha = false)
+	@sort_alphabetical = sort_alpha
   
     # hash of level_taxonomy to tag
     @tag_hash = Hash.new
@@ -89,13 +95,14 @@ class MasterTaxonomy
       path = current_taxonomy_path
     end
     puts "Saving current taxonomy to #{path}"
+	# this is really not JSON... it is a persisted format of ruby
     File.open(path, 'w') do |file|
       Marshal.dump(@tag_hash, file)
     end
   end
   
   # write taxonomy to xml
-  def write_xml(path)
+  def write_xml(path, output_type = 'tpex')
   
     root_tag = @tag_hash[""]
     
@@ -110,7 +117,7 @@ class MasterTaxonomy
       #setup the xml file
       xml.instruct!(:xml, :version=>"1.0", :encoding=>"UTF-8")
       xml.schema("xmlns:xsi"=>"http://www.w3.org/2001/XMLSchema-instance") {
-        write_tag_to_xml(root_tag, xml)       
+        write_tag_to_xml(root_tag, 0, xml, output_type)       
       }
     end
     
@@ -122,20 +129,28 @@ class MasterTaxonomy
   def get_terms(tag)
     
     terms = tag.terms
-    
+		
     parent_tag = tag.parent_tag
     while not parent_tag.nil?
-      terms.concat(parent_tag.terms)
+	  terms.concat(parent_tag.terms)
       parent_tag = parent_tag.parent_tag
     end
-
-    return terms.reverse.uniq
+	
+	
+	#sort the terms as they come out
+	result = terms.uniq
+	if !@sort_alphabetical
+	  result = result.sort {|x, y| x.row <=> y.row}
+	else
+	  result = result.sort {|x, y| x.name <=> y.name}
+	end
+	 
+    return result
   end
   
   # check that the given component is conforms with the master taxonomy
   def check_component(component)
     valid = true
-    
     tag = nil
     
     # see if we can find the component's tag in the taxonomy
@@ -208,6 +223,8 @@ class MasterTaxonomy
     # add root tag
     root_terms = []
     root_terms << TermStruct.new("", "", "", "", "OpenStudio Type", "Type of OpenStudio Object")
+	root_terms[0].row = 0
+	#root_terms << TermStruct.new()
     root_tag = TagStruct.new("", "root", "Root of the taxonomy", nil, [], root_terms)
     @tag_hash[""] = root_tag
 
@@ -234,39 +251,89 @@ class MasterTaxonomy
   
   
   def validate_terms_header(terms_worksheet)
-    header_error = false
-    
-    first_level      = terms_worksheet.Range("A2").Value
-    second_level     = terms_worksheet.Range("B2").Value
-    third_level      = terms_worksheet.Range("C2").Value
-    level_hierarchy  = terms_worksheet.Range("D2").Value
-    name             = terms_worksheet.Range("E2").Value
-    abbr             = terms_worksheet.Range("F2").Value
-    description      = terms_worksheet.Range("G2").Value
-    
-    header_error = true if not first_level == "First Level"
-    header_error = true if not second_level == "Second Level"
-    header_error = true if not third_level == "Third Level"
-    header_error = true if not level_hierarchy == "Level Hierarchy"
-    header_error = true if not name  == "Term"
-    header_error = true if not abbr  == "Abbr."
-    header_error = true if not description  == "Description"
-    
-    return header_error
+    test_arr = []
+	test_arr << "First Level"
+	test_arr << "Second Level"
+    test_arr << "Third Level"
+    test_arr << "Level Hierarchy"
+    test_arr << "Term"
+    test_arr << "Abbr"
+    test_arr << "Description"
+	test_arr << "Data Type"
+	test_arr << "Allow Multiple"
+	test_arr << "Enumerations"
+	test_arr << "IP Units Written Out"
+	test_arr << "IP Units Symbol"
+	test_arr << "IP Display Mask"
+	test_arr << "SI Units Written Out"
+	test_arr << "SI Units Symbol"
+	test_arr << "SI Display Mask"
+	test_arr << "Unit Conversion"
+	test_arr << "Default"
+	test_arr << "Min"
+	test_arr << "Max"
+	test_arr << "Source"
+	test_arr << "Review State"
+	test_arr << "General Comments"
+	test_arr << "Requested By / Project"
+	test_arr << "Include in TPE"
+	test_arr << "Required for Adding a New Product"
+	test_arr << "Use in Search Results"
+	test_arr << "Use in Search Facets"
+	test_arr << "Show/Hide Data from Data Users"
+	test_arr << "Additional Instructions for Web Developers"
+	test_arr << "Related Third Party Testing Standards"
+	test_arr << "Additional Guidance to Data Submitters"
+	test_arr << "Additional Guidance to Data Users"
+
+	
+	parse = true
+	col = 1
+	while parse
+	  if terms_worksheet.Columns(col).Rows(2).Value.nil? || col > test_arr.size
+	    parse = false
+	  else
+	    if not terms_worksheet.Columns(col).Rows(2).Value == test_arr[col-1]
+		  raise "Header does not match: #{col}: '#{terms_worksheet.Columns(col).Rows(2).Value} <> #{test_arr[col-1]}'"
+		end 
+	  end
+	  col += 1
+	end
   end
   
   def parse_term(terms_worksheet, row)
  
     term = TermStruct.new
-    term.first_level      = terms_worksheet.Range("A#{row}").Value
-    term.second_level     = terms_worksheet.Range("B#{row}").Value
-    term.third_level      = terms_worksheet.Range("C#{row}").Value
-    term.level_hierarchy  = terms_worksheet.Range("D#{row}").Value
-    term.name             = terms_worksheet.Range("E#{row}").Value
-    #term.abbr             = terms_worksheet.Range("F#{row}").Value
-    term.description      = terms_worksheet.Range("G#{row}").Value
-    
-    # trigger to quit parsing the xcel doc
+	term.row 				= row
+    term.first_level      	= terms_worksheet.Columns(1).Rows(row).Value
+    term.second_level     	= terms_worksheet.Columns(2).Rows(row).Value
+    term.third_level      	= terms_worksheet.Columns(3).Rows(row).Value
+    term.level_hierarchy  	= terms_worksheet.Columns(4).Rows(row).Value
+    term.name             	= terms_worksheet.Columns(5).Rows(row).Value
+    term.abbr             	= terms_worksheet.Columns(6).Rows(row).Value
+    term.description      	= terms_worksheet.Columns(7).Rows(row).Value
+	term.data_type		  	= terms_worksheet.Columns(8).Rows(row).Value
+	term.allow_multiple	  	= terms_worksheet.Columns(9).Rows(row).Value
+	term.enums    		  	= terms_worksheet.Columns(10).Rows(row).Value
+	term.ip_written			= terms_worksheet.Columns(11).Rows(row).Value
+	term.ip_symbol			= terms_worksheet.Columns(12).Rows(row).Value
+	term.ip_mask			= terms_worksheet.Columns(13).Rows(row).Value
+	term.si_written			= terms_worksheet.Columns(14).Rows(row).Value
+	term.si_symbol			= terms_worksheet.Columns(15).Rows(row).Value
+	term.si_mask			= terms_worksheet.Columns(16).Rows(row).Value
+	
+	#custom TPex Columns
+	term.tp_include				= terms_worksheet.Columns(25).Rows(row).Value
+	term.tp_required			= terms_worksheet.Columns(26).Rows(row).Value
+	term.tp_use_in_search		= terms_worksheet.Columns(27).Rows(row).Value
+	term.tp_use_in_facets		= terms_worksheet.Columns(28).Rows(row).Value
+	term.tp_hide_from_data_users	= terms_worksheet.Columns(29).Rows(row).Value
+	term.tp_third_party_testing		= terms_worksheet.Columns(30).Rows(row).Value
+	term.tp_additional_web_dev_info			= terms_worksheet.Columns(31).Rows(row).Value
+	term.tp_additional_data_user_info		= terms_worksheet.Columns(32).Rows(row).Value
+	term.tp_additional_data_submitter_info	= terms_worksheet.Columns(33).Rows(row).Value
+	
+	# trigger to quit parsing the xcel doc
     if term.first_level.nil? or term.first_level.empty?
       return nil
     end
@@ -327,17 +394,21 @@ class MasterTaxonomy
   end
   
   def sort_tag(tag)
-    tag.terms = tag.terms.sort {|x, y| x.name <=> y.name}
-    tag.child_tags = tag.child_tags.sort {|x, y| x.name <=> y.name}
+    #tag.terms = tag.terms.sort {|x, y| x.level_hierarchy <=> y.level_hierarchy}
+    tag.child_tags = tag.child_tags.sort {|x, y| x.level_hierarchy <=> y.level_hierarchy}
     tag.child_tags.each {|child_tag| sort_tag(child_tag) }
+  
+    #tag.terms = tag.terms.sort {|x, y| x.name <=> y.name}
+    #tag.child_tags = tag.child_tags.sort {|x, y| x.name <=> y.name}
+    #tag.child_tags.each {|child_tag| sort_tag(child_tag) }
   end
   
   def check_tag(tag)
     
     if tag.description.nil? or tag.description.empty?
-      puts "tag '#{tag.level_hierarchy}' has no description"
+      #puts "tag '#{tag.level_hierarchy}' has no description"
     end
-    
+	
     tag.terms.each {|term| check_term(term) }
     tag.child_tags.each {|child_tag| check_tag(child_tag) }
   end
@@ -372,34 +443,92 @@ class MasterTaxonomy
       valid = false
     end
     
-    # todo: check description, data type, enumerations, units, source, author
+	if !term.data_type.nil?
+	  valid_types = ["double", "integer", "enum", "file", "string"]
+	  if (term.data_type.downcase != term.data_type) || !valid_types.include?(term.data_type) 
+ 	    puts "[ERROR] Term '#{term.name}' does not have a valid data type with '#{term.data_type}'"
+	  end
+	  
+	  if term.data_type.downcase == "enum"
+	    if term.enums.nil? || term.enums == "" || term.enums.downcase == "no enum found"
+		  puts "[ERROR] Term '#{term.name}' does not have valid enumerations"
+		end
+	  end
+	end
     
     return valid
   end
   
   def check_term(term)
     if term.description.nil? or term.description.empty?
-      puts "term '#{term.level_hierarchy}.#{term.name}' has no description"
+      #puts "term '#{term.level_hierarchy}.#{term.name}' has no description"
     end
   end
   
+  # write term to xml
+  def write_terms_to_xml(tag, xml, output_type)
+    terms = get_terms(tag) 
+	if terms.size > 0
+      terms.each do |term|
+	    xml.term {
+  	      xml.name term.name
+	      xml.abbr term.abbr if !term.abbr.nil? 
+		  xml.description term.description if !term.description.nil?
+		  xml.data_type term.data_type if !term.data_type.nil?
+		  xml.allow_multiple term.allow_multiple if !term.allow_multiple.nil?
+		  
+		  if !term.enums.nil? && term.enums != "" 
+		    xml.enumerations {
+			  out = term.enums.split("|")
+			  out.sort! if @sort_alphabetical
+			  out.each do |enum|
+  			    xml.enumeration enum
+			  end
+			}
+		  end
+		  xml.ip_written term.ip_written if !term.ip_written.nil?
+		  xml.ip_symbol term.ip_symbol if !term.ip_symbol.nil?
+		  xml.ip_mask term.ip_mask if !term.ip_mask.nil?
+		  xml.si_written term.si_written if !term.si_written.nil?
+		  xml.si_symbol term.si_symbol if !term.si_symbol.nil?
+		  xml.si_mask term.si_mask if !term.si_mask.nil?
+		  xml.row term.row if !term.row.nil?
+
+		  if output_type == 'tpex'
+		    xml.tp_include term.tp_include if !term.tp_include.nil?
+			xml.tp_required term.tp_required if !term.tp_required.nil?
+			xml.tp_use_in_search term.tp_use_in_search if !term.tp_use_in_search.nil?
+			xml.tp_use_in_facets term.tp_use_in_facets if !term.tp_use_in_facets.nil?
+			xml.tp_hide_from_data_users term.tp_hide_from_data_users if !term.tp_hide_from_data_users.nil?
+			xml.tp_third_party_testing term.tp_third_party_testing if !term.tp_third_party_testing.nil?
+			xml.tp_additional_web_dev_info term.tp_additional_web_dev_info if !term.tp_additional_web_dev_info.nil?
+			xml.tp_additional_data_user_info term.tp_additional_data_user_info if !term.tp_additional_data_user_info.nil?
+			xml.tp_additional_data_submitter_info term.tp_additional_data_submitter_info if !term.tp_additional_data_submitter_info.nil?
+		  end
+	    }
+	  end
+	end
+  end
+  
   # write a tag to xml
-  def write_tag_to_xml(tag, xml)
-    xml.tag(:name => "#{tag.name}") {
-      #xml.terms {
-        #terms = tag.terms # only direct terms
-        terms = get_terms(tag) # all terms, ordered by inheritence
-        terms.each do |term|
-          xml.term(:name => "#{term.name}")
-        end
-      #}
-      #xml.tags {
-        child_tags = tag.child_tags
-        child_tags.each do |child_tag|
-          write_tag_to_xml(child_tag, xml)
-        end
-      #}
-    }
+  def write_tag_to_xml(tag, level, xml, output_type)
+    level_string = "level_#{level}"
+	xml.tag!(level_string) {
+	  s_temp = tag.name 
+	  xml.name s_temp
+	  	  
+	  level += 1
+	    
+	  if tag.child_tags.size == 0
+	    write_terms_to_xml(tag, xml, output_type)
+	  end
+	  
+	  child_tags = tag.child_tags
+      child_tags.each do |child_tag|
+        write_tag_to_xml(child_tag, level, xml, output_type)
+      end
+		 
+	}
   end
   
 end