conv.rb in asciimath2unitsml-0.2.1

- old
+ new

@@ -33,10 +33,14 @@
       end
       @parser = parser
       @multiplier = multiplier(options[:multiplier] || "\u00b7")
     end
 
+    def float_to_display(f)
+      ret = f.to_f.round(1).to_s.sub(/\.0$/, "")
+    end
+
     def prefix(units)
       units.map { |u| u[:prefix] }.reject { |u| u.nil? }.uniq.map do |p|
         <<~END
         <Prefix xmlns='#{UNITSML_NS}' prefixBase='#{@prefixes[p].base}'
                 prefixPower='#{@prefixes[p].power}' xml:id='#{@prefixes[p].id}'>
@@ -59,31 +63,33 @@
       END
     end
 
     def units2dimensions(units)
       norm = decompose_units(units)
-      return if norm.any? { |u| u[:unit] == "unknown" || u[:prefix] == "unknown" }
+      return if norm.any? { |u| u[:unit] == "unknown" || u[:prefix] == "unknown" || u[:unit].nil? }
       norm.map do |u|
         { dimension: U2D[u[:unit]][:dimension],
           unit: u[:unit],
           exponent: u[:exponent] || 1,
           symbol: U2D[u[:unit]][:symbol] } 
       end.sort { |a, b| U2D[a[:unit]][:order] <=> U2D[b[:unit]][:order] }
     end
 
     def dimension1(u)
-      %(<#{u[:dimension]} symbol="#{u[:symbol]}" powerNumerator="#{u[:exponent]}"/>)
+      %(<#{u[:dimension]} symbol="#{u[:symbol]}" powerNumerator="#{float_to_display(u[:exponent])}"/>)
     end
 
     def dim_id(dims)
       return nil if dims.nil? || dims.empty?
       dimhash = dims.each_with_object({}) { |h, m| m[h[:dimension]] = h }
       dimsvector = %w(Length Mass Time ElectricCurrent ThermodynamicTemperature 
                       AmountOfSubstance LuminousIntensity PlaneAngle)
         .map { |h| dimhash.dig(h, :exponent) }.join(":")
       id = @dimensions_id&.values&.select { |d| d.vector == dimsvector }&.first&.id and return id.to_s
-      "D_" + dims.map { |d| U2D[d[:unit]][:symbol] + (d[:exponent] == 1 ? "" : d[:exponent].to_s) }.join("")
+      "D_" + dims.map do |d|
+        U2D[d[:unit]][:symbol] + (d[:exponent] == 1 ? "" : float_to_display(d[:exponent]))
+      end.join("")
     end
 
     def decompose_units(units)
       gather_units(units_only(units).map { |u| decompose_unit(u) }.flatten)
     end
@@ -92,37 +98,38 @@
       units.sort { |a, b| a[:unit] <=> b[:unit] }.each_with_object([]) do |k, m|
         if m.empty? || m[-1][:unit] != k[:unit] then m << k
         else
           m[-1] = { prefix: combine_prefixes(@prefixes[m[-1][:prefix]], @prefixes[k[:prefix]]),
                     unit: m[-1][:unit],
-                    exponent: (k[:exponent]&.to_i || 1) + (m[-1][:exponent]&.to_i || 1) }
+                    exponent: (k[:exponent]&.to_f || 1) + (m[-1][:exponent]&.to_f || 1) }
         end
       end
     end
 
     # treat g not kg as base unit: we have stripped the prefix k in parsing
     # reduce units down to basic units
     def decompose_unit(u)
-      if u[:unit] == "g" then u
+      if u[:unit].nil? then u
+      elsif u[:unit] == "g" then u
       elsif @units[u[:unit]].system_type == "SI_base" then u
       elsif !@units[u[:unit]].si_derived_bases
         { prefix: u[:prefix], unit: "unknown", exponent: u[:exponent] }
       else
         @units[u[:unit]].si_derived_bases.each_with_object([]) do |k, m|
           m << { prefix: !k[:prefix].nil? && !k[:prefix].empty? ? 
                  combine_prefixes(@prefixes_id[k[:prefix]], @prefixes[u[:prefix]]) : u[:prefix],
                  unit: @units_id[k[:id]].symbolid,
-                 exponent: (k[:power]&.to_i || 1) * (u[:exponent]&.to_i || 1) }
+                 exponent: (k[:power]&.to_i || 1) * (u[:exponent]&.to_f || 1) }
         end
       end
     end
 
     def combine_prefixes(p1, p2)
       return nil if p1.nil? && p2.nil?
       return p1.symbolid if p2.nil?
       return p2.symbolid if p1.nil?
       return "unknown" if p1.base != p2.base
-      @prefixes.each do |p|
+      @prefixes.each do |_, p|
         return p.symbolid if p.base == p1.base && p.power == p1.power + p2.power
       end
       "unknown"
     end
 