asciimath2unitsml 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d2ef44eb717d6b445489de85ee1e8eb3f5b81a6d83602c48ea23a8cbe4f100c7
+  data.tar.gz: 84b867f5a97b3ad154c7be8e5975ca4c97446049c4368ece6ae5e23da3c94437
+SHA512:
+  metadata.gz: b749aa65924f4b815a7d38d2df9c9d6b48e4cd8f9db62678c100d732a60c8159b537fa2c3bd192296f533371f731ec85365f0d7f231f560f173d167971c38871
+  data.tar.gz: 64a47773ef26b6b870fc6a4406b697ec10b943e637a82f549946d8126830db9a521f3bdcb4e314718d084e40b7cfacbc820417476cd98663760ec8de29ba566e

data/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+  
+# Specify your gem's dependencies in ruby-vobject.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,25 @@
+BSD 2-Clause License
+
+Copyright (c) 2021, Plurimath from Ribose
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.adoc

@@ -0,0 +1,80 @@
+= asciimath2unitsml
+Convert Asciimath via MathML to UnitsML
+
+Encode UnitsML expressions in AsciiMath as `"unitsml(...)"`. The gem converts 
+AsciiMath incorporating UnitsML expressions (based on the Ascii representation provided by NIST)
+into MathML complying with https://www.w3.org/TR/mathml-units/[], with
+UnitsML markup embedded in it, with identifiers for each unit and dimension. 
+The consuming document is meant to deduplicate the instances of UnitsML markup
+with the same identifier, and potentially remove them to elsewhere in the document
+or another document.
+
+The AsciiMath conventions used are:
+
+* `^` for exponents, e.g. `m^-2`
+* `*` to combine two units by multiplication; e.g. `m*s^-2`. Division is not supported, use negative exponents instead
+* `u` for μ (micro-)
+
+So 
+
+[source]
+----
+9 "unitsml(C^3*A)"
+----
+
+is converted into:
+
+[source,xml]
+----
+<math xmlns='http://www.w3.org/1998/Math/MathML'>
+  <mrow>
+    <mn>9</mn>
+         <mo rspace='thickmathspace'>&#x2062;</mo>
+         <mrow xref='U_C3.A'>
+           <msup>
+             <mrow>
+               <mi mathvariant='normal'>C</mi>
+             </mrow>
+             <mrow>
+               <mn>3</mn>
+             </mrow>
+           </msup>
+           <mo>&#xB7;</mo>
+           <mi mathvariant='normal'>A</mi>
+         </mrow>
+
+         <Unit xmlns='http://unitsml.nist.gov/2005' xml:id='U_C3.A' dimensionURL='#D_T3I4'>
+           <UnitSystem name='SI' type='SI_derived' xml:lang='en-US'/>
+           <UnitName xml:lang='en'>C^3*A</UnitName>
+           <UnitSymbol type='HTML'>C<sup>3</sup> &#xB7; A</UnitSymbol>
+           <UnitSymbol type='MathML'>
+             <math xmlns='http://www.w3.org/1998/Math/MathML'>
+               <mrow>
+                 <msup>
+                   <mrow>
+                     <mi mathvariant='normal'>C</mi>
+                   </mrow>
+                   <mrow>
+                     <mn>3</mn>
+                   </mrow>
+                 </msup>
+                 <mo>&#xB7;</mo>
+                 <mi mathvariant='normal'>A</mi>
+               </mrow>
+             </math>
+           </UnitSymbol>
+           <RootUnits>
+             <EnumeratedRootUnit unit='coulomb' powerNumerator='3'/>
+             <EnumeratedRootUnit unit='ampere'/>
+           </RootUnits>
+         </Unit>
+         <Dimension xmlns='http://unitsml.nist.gov/2005' xml:id='D_T3I4'>
+           <Time symbol='T' powerNumerator='3'/>
+           <ElectricCurrent symbol='I' powerNumerator='4'/>
+         </Dimension>
+
+  </mrow>
+</math>
+----
+
+

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/asciimath2unitsml.gemspec

@@ -0,0 +1,43 @@
+# coding: utf-8
+  
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "asciimath2unitsml/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "asciimath2unitsml"
+  spec.version       = Asciimath2UnitsML::VERSION
+  spec.authors       = ["Ribose Inc."]
+  spec.email         = ["open.source@ribose.com"]
+
+  spec.summary       = "Convert Asciimath via MathML to UnitsML"
+  spec.description   = <<~DESCRIPTION
+  Convert Asciimath via MathML to UnitsML
+  DESCRIPTION
+
+  spec.homepage      = "https://github.com/plurimath/asciimath2unitsml"
+  spec.license       = "BSD-2-Clause"
+
+  spec.bindir        = "bin"
+  spec.require_paths = ["lib"]
+  spec.files         = `git ls-files`.split("\n")
+  spec.test_files    = `git ls-files -- {spec}/*`.split("\n")
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.4.0")
+
+  spec.add_dependency "asciimath"
+  spec.add_dependency "htmlentities"
+  spec.add_dependency "nokogiri", "~> 1.10.4"
+  spec.add_dependency "rsec", "~> 1.0.0"
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "byebug", "~> 9.1"
+  spec.add_development_dependency "equivalent-xml", "~> 0.6"
+  spec.add_development_dependency "guard", "~> 2.14"
+  spec.add_development_dependency "guard-rspec", "~> 4.7"
+  spec.add_development_dependency "rake", "~> 12.0"
+  spec.add_development_dependency "rspec", "~> 3.6"
+  spec.add_development_dependency "rubocop", "= 0.54.0"
+  spec.add_development_dependency "simplecov", "~> 0.15"
+  spec.add_development_dependency "timecop", "~> 0.9"
+end
+

data/bin/rspec

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+  
+# This file was generated by Bundler.
+#
+# The application 'rspec' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require "pathname"
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path(
+  "../../Gemfile", Pathname.new(__FILE__).realpath
+)
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("rspec-core", "rspec")
+

data/lib/asciimath2unitsml.rb

@@ -0,0 +1,3 @@
+require_relative "asciimath2unitsml/version"
+require_relative "asciimath2unitsml/conv"
+

data/lib/asciimath2unitsml/conv.rb

@@ -0,0 +1,240 @@
+require "asciimath"
+require "nokogiri"
+require "htmlentities"
+require "yaml"
+require "rsec"
+require_relative "string"
+require_relative "parse"
+
+module Asciimath2UnitsML
+  MATHML_NS = "http://www.w3.org/1998/Math/MathML".freeze
+  UNITSML_NS = "http://unitsml.nist.gov/2005".freeze
+
+  class Conv
+    def initialize
+      @prefixes_id = read_yaml("../unitsdb/prefixes.yaml")
+      @prefixes = flip_name_and_id(@prefixes_id)
+      @quantities = read_yaml("../unitsdb/quantities.yaml")
+      @units_id = read_yaml("../unitsdb/units.yaml")
+      @units = flip_name_and_id(@units_id)
+      @parser = parser
+    end
+
+    # https://www.w3.org/TR/mathml-units/ section 2: delimit number Invisible-Times unit
+    def Asciimath2UnitsML(expression)
+      xml = Nokogiri::XML(asciimath2mathml(expression))
+      MathML2UnitsML(xml).to_xml
+    end
+
+    def MathML2UnitsML(xml)
+      xml.xpath(".//m:mtext", "m" => MATHML_NS).each do |x|
+        next unless %r{^unitsml\(.+\)$}.match(x.text)
+        text = x.text.sub(%r{^unitsml\((.+)\)$}m, "\\1")
+        units = parse(text)
+        delim = x&.previous_element&.name == "mn" ? "<mo rspace='thickmathspace'>&#x2062;</mo>" : ""
+        x.replace("#{delim}<mrow xref='#{unit_id(text)}'>#{mathmlsymbol(units)}</mrow>\n#{unitsml(units, text)}")
+      end
+      xml
+    end
+
+    def asciimath2mathml(expression)
+      AsciiMath::MathMLBuilder.new(:msword => true).append_expression(
+        AsciiMath.parse(HTMLEntities.new.decode(expression)).ast).to_s.
+      gsub(/<math>/, "<math xmlns='#{MATHML_NS}'>")
+    end
+
+    def unit_id(text)
+      "U_" +
+        (@units[text.to_sym] ? @units[text.to_sym][:id] : text.gsub(/\*/, ".").gsub(/\^/, ""))
+    end
+
+    def unit(units, text, dims)
+      dimid = dim_id(dims)
+      <<~END
+      <Unit xmlns='#{UNITSML_NS}' xml:id='#{unit_id(text)}'#{dimid ? " dimensionURL='##{dimid}'" : ""}>
+      #{unitsystem(units)}
+      #{unitname(units, text)}
+      #{unitsymbol(units)}
+      #{rootunits(units)}
+      </Unit>
+      END
+    end
+
+    def unitsystem(units)
+      ret = []
+      units.any? { |x| @units[x[:unit].to_sym][:si] != true } and
+        ret << "<UnitSystem name='not_SI' type='not_SI' xml:lang='en-US'/>"
+      if units.any? { |x| @units[x[:unit].to_sym][:si] == true }
+        base = units.size == 1 && @units[units[0][:unit].to_sym][:type].include?("si-base")
+        ret << "<UnitSystem name='SI' type='#{base ? "SI_base" : "SI_derived"}' xml:lang='en-US'/>"
+      end
+      ret.join("\n")
+    end
+
+    def unitname(units, text)
+      name = @units[text.to_sym] ? @units[text.to_sym][:name] : compose_name(units, text)
+      "<UnitName xml:lang='en'>#{name}</UnitName>"
+    end
+
+    # TODO: compose name from the component units
+    def compose_name(units, text)
+      text
+    end
+
+    def unitsymbol(units)
+      <<~END
+      <UnitSymbol type="HTML">#{htmlsymbol(units)}</UnitSymbol>
+      <UnitSymbol type="MathML">#{mathmlsymbolwrap(units)}</UnitSymbol>
+      END
+    end
+
+    def htmlsymbol(units)
+      units.map do |u|
+        u[:exponent] and exp = "<sup>#{u[:exponent].sub(/-/, "&#x2212;")}</sup>"
+        "#{u[:prefix]}#{u[:unit]}#{exp}"
+      end.join(" &#183; ")
+    end
+
+    def mathmlsymbol(units)
+      exp = units.map do |u|
+        base = "<mi mathvariant='normal'>#{u[:prefix]}#{u[:unit]}</mi>"
+        if u[:exponent]
+          exp = "<mn>#{u[:exponent]}</mn>".sub(/<mn>-/, "<mo>&#x2212;</mo><mn>")
+          "<msup><mrow>#{base}</mrow><mrow>#{exp}</mrow></msup>"
+        else
+          base
+        end
+      end.join("<mo>&#xB7;</mo>")
+    end
+
+    def mathmlsymbolwrap(units)
+      <<~END
+      <math xmlns='#{MATHML_NS}'>
+      <mrow>#{mathmlsymbol(units)}</mrow>
+      </math>
+      END
+    end
+
+    def rootunits(units)
+      return if units.size == 1
+      exp = units.map do |u|
+        prefix = " prefix='#{u[:prefix]}'" if u[:prefix]
+        exponent = " powerNumerator='#{u[:exponent]}'" if u[:exponent]
+        "<EnumeratedRootUnit unit='#{@units[u[:unit].to_sym][:name]}'#{prefix}#{exponent}/>"
+      end.join("\n")
+      <<~END
+      <RootUnits>#{exp}</RootUnits>
+      END
+    end
+
+    def prefix(units)
+      units.map { |u| u[:prefix] }.reject { |u| u.nil? }.uniq.map do |p1|
+        p = p1.to_sym
+        <<~END
+        <Prefix xmlns='#{UNITSML_NS}' prefixBase='#{@prefixes[p][:base]}'
+                prefixPower='#{@prefixes[p][:power]}' xml:id='#{@prefixes[p][:id]}'>
+          <PrefixName xml:lang="en">#{@prefixes[p][:name]}</PrefixName>
+          <PrefixSymbol type="ASCII">#{@prefixes[p][:symbol]}</PrefixSymbol>
+        </Prefix>
+        END
+      end.join("\n")
+    end
+
+    def dimension(dims)
+      return if dims.nil? || dims.empty?
+      <<~END
+      <Dimension xmlns='#{UNITSML_NS}' xml:id="#{dim_id(dims)}">
+      #{dims.map { |u| dimension1(u) }.join("\n") }
+      </Dimension>
+      END
+    end
+
+    U2D = {
+      "m" => { dimension: "Length", order: 1, symbol: "L" },
+      "g" => { dimension: "Mass", order: 2, symbol: "M" },
+      "kg" => { dimension: "Mass", order: 2, symbol: "M" },
+      "s" => { dimension: "Time", order: 3, symbol: "T" },
+      "A" => { dimension: "ElectricCurrent", order: 4, symbol: "I" },
+      "K" => { dimension: "ThermodynamicTemperature", order: 5, symbol: "Theta" },
+      "mol" => { dimension: "AmountOfSubstance", order: 6, symbol: "N" },
+      "cd" => { dimension: "LuminousIntensity", order: 7, symbol: "J" },
+    }
+
+    def units2dimensions(units)
+      norm = normalise_units(units)
+      return if norm.any? { |u| u[:unit] == "unknown" || u[:prefix] == "unknown" }
+      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]}"/>)
+    end
+
+    def dim_id(dims)
+      return nil if dims.nil? || dims.empty?
+      "D_" + dims.map { |d| U2D[d[:unit]][:symbol] + (d[:exponent] == 1 ? "" : d[:exponent].to_s) }.join("")
+    end
+
+    def normalise_units(units)
+      gather_units(units.map { |u| normalise_unit(u) }.flatten)
+    end
+
+    def gather_units(units)
+      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) }
+        end
+      end
+    end
+
+    def normalise_unit(u)
+      if @units[u[:unit].to_sym][:type]&.include?("si-base") then u
+      elsif !@units[u[:unit].to_sym][:bases] then { prefix: u[:prefix], unit: "unknown", exponent: u[:exponent] }
+      else
+        @units[u[:unit].to_sym][:bases].each_with_object([]) do |k, m|
+          m << { prefix: k["prefix"] ?
+                 combine_prefixes(@prefixes_id[k["prefix"]], @prefixes[u[:prefix]]) : u[:prefix],
+                 unit: @units_id[k["id"].to_sym][:symbol],
+                 exponent: (k["power"]&.to_i || 1) * (u[:exponent]&.to_i || 1) }
+        end
+      end
+    end
+
+    def combine_prefixes(p1, p2)
+      return nil if p1.nil? && p2.nil?
+      return p1[:symbol] if p2.nil?
+      return p2[:symbol] if p1.nil?
+      return "unknown" if p1[:base] != p2[:base]
+      @prefixes.each do |p|
+        return p[:symbol] if p[:base] == p1[:base] && p[:power] == p1[:power] + p2[:power]
+      end
+      "unknown"
+    end
+
+    def parse(x)
+      units = @parser.parse(x)
+      if !units || Rsec::INVALID[units]
+        raise Rsec::SyntaxError.new "error parsing UnitsML expression", x, 1, 0
+      end
+      Rsec::Fail.reset
+      units
+    end
+
+    def unitsml(units, text)
+      dims = units2dimensions(units)
+      <<~END
+      #{unit(units, text, dims)}
+      #{prefix(units)}
+      #{dimension(dims)}
+      END
+    end
+  end
+end

data/lib/asciimath2unitsml/parse.rb

@@ -0,0 +1,58 @@
+module Asciimath2UnitsML
+  class Conv
+    include Rsec::Helpers
+
+    def read_yaml(path)
+      symbolize_keys(YAML.load_file(File.join(File.join(File.dirname(__FILE__), path))))
+    end
+
+    def flip_name_and_id(yaml)
+      yaml.each_with_object({}) do |(k, v), m|
+        next if v[:name].nil? || v[:name].empty?
+        symbol = v[:symbol] || v[:short]
+        m[symbol.to_sym] = v
+        m[symbol.to_sym][:symbol] = symbol
+        m[symbol.to_sym][:id] = k.to_s
+      end
+    end
+
+    def symbolize_keys(hash)
+      hash.inject({})do |result, (key, value)|
+        new_key = case key
+                  when String then key.to_sym
+                  else key
+                  end
+        new_value = case value
+                    when Hash then symbolize_keys(value)
+                    else value
+                    end
+        result[new_key] = new_value
+        result
+      end
+    end
+
+    def parser
+      prefix = /#{@prefixes.keys.join("|")}/.r
+      unit_keys = @units.keys.reject do |k|
+        @units[k][:type]&.include?("buildable") || /\*|\^/.match(k)
+      end.map { |k| Regexp.escape(k) }
+      unit1 = /#{unit_keys.sort_by(&:length).reverse.join("|")}/.r
+      exponent = /\^-?\d+/.r.map { |m| m.sub(/\^/, "") }
+      multiplier = /\*/.r
+      unit = seq(unit1, exponent._?) { |x| { prefix: nil, unit: x[0], exponent: x[1][0] } } |
+        seq(prefix, unit1, exponent._?) { |x| { prefix: x[0][0], unit: x[1], exponent: x[2][0] } }
+      units_tail = seq(multiplier, unit) { |u| u[1] }
+      units = seq(unit, units_tail.star) { |x| [x[0], x[1]].flatten }
+      parser = units.eof
+    end
+
+    def parse(x)
+      units = @parser.parse(x)
+      if !units || Rsec::INVALID[units]
+        raise Rsec::SyntaxError.new "error parsing UnitsML expression", x, 1, 0
+      end
+      Rsec::Fail.reset
+      units
+    end
+  end
+end