asciimath2unitsml 0.0.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d2ef44eb717d6b445489de85ee1e8eb3f5b81a6d83602c48ea23a8cbe4f100c7
-  data.tar.gz: 84b867f5a97b3ad154c7be8e5975ca4c97446049c4368ece6ae5e23da3c94437
+  metadata.gz: ca1751cf852b77599154aa142ea719f0510210ddebb667ace7225cb94f7d598f
+  data.tar.gz: 332e23b81a688d1386a4f084dc3db1f401e1e7634beb70c17466e18a23d1f51a
 SHA512:
-  metadata.gz: b749aa65924f4b815a7d38d2df9c9d6b48e4cd8f9db62678c100d732a60c8159b537fa2c3bd192296f533371f731ec85365f0d7f231f560f173d167971c38871
-  data.tar.gz: 64a47773ef26b6b870fc6a4406b697ec10b943e637a82f549946d8126830db9a521f3bdcb4e314718d084e40b7cfacbc820417476cd98663760ec8de29ba566e
+  metadata.gz: f300b5a9c8af814f4c61ff9be4407f45350fedfc76a7c9b3e4da90a793fcf5cf7004b24e5719a562cc2cb355bb8be355ee4d1e23909f6bbbd4060a97affcd7de
+  data.tar.gz: abeedd889b14c45eeeb90a2f56fc5a09de04ca54f7b15f39677ad516fda17426dbd47977fdc71199ed77424639dd4c86a40164672dd81aad92fd512f872b1723

data/.github/workflows/rake.yml

@@ -0,0 +1,53 @@
+# Auto-generated by Cimas: Do not edit it manually!
+# See https://github.com/metanorma/cimas
+name: rake
+
+on:
+  push:
+    branches: [ master, main ]
+    tags: [ v* ]
+  pull_request:
+
+jobs:
+  rake:
+    name: Test on Ruby ${{ matrix.ruby }} ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    continue-on-error: ${{ matrix.experimental }}
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby: [ '2.7', '2.6', '2.5', '2.4' ]
+        os: [ ubuntu-latest, windows-latest, macos-latest ]
+        experimental: [ false ]
+        include:
+          - ruby: '3.0'
+            os: 'ubuntu-latest'
+            experimental: true
+          - ruby: '3.0'
+            os: 'windows-latest'
+            experimental: true
+          - ruby: '3.0'
+            os: 'macos-latest'
+            experimental: true
+    steps:
+      - uses: actions/checkout@master
+        with:
+          submodules: true
+
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+          bundler-cache: true
+
+      - run: bundle exec rake
+
+  tests-passed:
+    needs: rake
+    runs-on: ubuntu-latest
+    steps:
+      - uses: peter-evans/repository-dispatch@v1
+        with:
+          token: ${{ secrets.METANORMA_CI_PAT_TOKEN || secrets.GITHUB_TOKEN }}
+          repository: ${{ github.repository }}
+          event-type: notify
+          client-payload: '{"ref": "${{ github.ref }}", "sha": "${{ github.sha }}"}'

data/.gitmodules

@@ -0,0 +1,4 @@
+[submodule "lib/unitsdb"]
+	branch = master
+	path = lib/unitsdb
+	url = https://github.com/unitsml/unitsdb.git

data/README.adoc

@@ -1,21 +1,60 @@
 = asciimath2unitsml
-Convert Asciimath via MathML to UnitsML
+Convert Units expressions 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)
+This gem converts 
+MathML 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. 
+UnitsML markup embedded in it, and with unique identifiers for each distinct unit, prefix, and dimension. 
+Dimensions are automatically inserted corresponding to each unit.
+Units expressions are identified in MathML as `<mtext>unitsml(...)</mtext>`, which in turn
+can be identified in AsciiMath  as `"unitsml(...)"`. 
+
 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:
+== Notation
+
+The `unitsml()` expression consists of a unit string.
+The units used in `unitsml()` are taken from the UnitsDB database as updated by Ribose:
+https://github.com/unitsml/unitsdb[]. Units are given as an ASCII based code, consisting of
+multiplication or division of single units, each of which is defined as a Prefix
+(taken from https://github.com/unitsml/unitsdb/blob/master/prefixes.yaml[]),
+unit (taken from https://github.com/unitsml/unitsdb/blob/master/units.yaml[]),
+and exponent; e.g. `mm*s^-2`. 
+
+The conventions used for writing units 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
+* `*` to combine two units by multiplication; e.g. `m*s^-2`. 
+* `/` to combine two units by division;
 * `u` for μ (micro-)
 
-So 
+For more on units notation, see <<units_notation,Units Notation>>.
+
+The `unitsml()` can take additional optional parameters, giving further information for the UnitsML
+to be generated:
+
+* `unitsml(unit-string, quantity: ID)` provides the UnitsDB identifier for the quantity being measured
+(taken from https://github.com/unitsml/unitsdb/blob/master/quantities.yaml[]). For example,
+`unitsml(s, quantity: NISTq109)` indicates that the second is used to measure period duration.
+If a single quantity is associated with the unit in UnitsDB (as given in
+https://github.com/unitsml/unitsdb/blob/master/units.yaml[]), that quantity is added automatically;
+otherwise, no quantity is added unless explicitly nominated in this way.
+* `unitsml(unit-string, name: NAME)` provides a name for the unit, if one is not already available
+from UnitsDB. For example, `unitsml(cal_th/cm^2, name: langley)`.
+
+== Rendering
+
+The output of the gem is MathML, with MathML unit expressions (expressed as `<mi>`, 
+complying with https://www.w3.org/TR/mathml-units/[MathML Units]) cross-referenced to UnitsML
+definitions embedded in the MathML.
+
+The gem follows the MathML Units convention of inserting a spacing invisible times operator
+(`<mo rspace='thickmathspace'>&#x2062;</mo>`) between any numbers (`<mn>`) and unit expressions
+in MathML, and representing units in MathML as non-italic variables (`<mi mathvariant='normal'>`).
+
+== Example
 
 [source]
 ----
@@ -77,4 +116,129 @@ is converted into:
 </math>
 ----
 
+== Usage
+
+The converter is run as:
+
+[source,ruby]
+----
+c = Asciimath2UnitsML::Conv.new()
+c.Asciimath2UnitsML(1 "unitsml(mm*s^-2)") # AsciiMath string containing UnitsML
+c.MathML2UnitsML("<math xmlns='http://www.w3.org/1998/Math/MathML'><mn>7</mn>"\
+  "<mtext>unitsml(kg^-2)</mtext></math>") # AsciiMath string containing <mtext>unitsml()</mtext>
+c.MathML2UnitsML(Nokogiri::XML("<math xmlns='http://www.w3.org/1998/Math/MathML'><mn>7</mn>"\
+  "<mtext>unitsml(kg^-2)</mtext></math>")) # Nokogiri parse of MathML document containing <mtext>unitsml()</mtext>
+----
+
+The converter class may be initialised with options:
+
+* `multiplier` is the symbol used to represent the multiplication of units. By default,
+following MathML Units, the symbol is middle dot (`&#xB7`). An arbitrary UTF-8 string can be
+supplied instead; it will be encoded as XML entities. The value `:space` is rendered
+as a spacing invisible times in MathML (`<mo rspace='thickmathspace'>&#x2062;</mo>`),
+and as a non-breaking space in HTML. The value `:nospace` is rendered as a non-spacing
+invisible times in MathML (`<mo>&#x2062;</mo>`), and is not rendered in HTML.
+
+[[units_notation]]
+== Units Notation
+
+The units used in `unitsml()` are taken from the UnitsDB database as updated by Ribose:
+https://github.com/unitsml/unitsdb[]. Units are given as an ASCII based code, consisting of
+multiplication or division of single units, each of which is defined as a Prefix 
+(taken from https://github.com/unitsml/unitsdb/blob/master/prefixes.yaml[]),
+unit (taken from https://github.com/unitsml/unitsdb/blob/master/units.yaml[]),
+and exponent; e.g. `mm*s^-2`. 
+
+In case of ambiguity, the interpretation with no prefix is prioritised over the interpretation
+as a unit; so `ct` is interpreted as _hundredweight_, rather than _centi-ton_. Exceptionally,
+`kg` is decomposed into kilo-gram rather than treated as a basic unit, for consistency with
+other prefixes of grams. (Prefixed units appear in UnitsDB, and are indicated as `prefixed: true`.)
+
+A unit may have multiple symbols; these are registered separately in 
+https://github.com/unitsml/unitsdb/units.yaml[units.yaml], as entries under `unit_symbols`.
+These different symbols will be recognised as the same Unit in the UnitsML markup, but
+the original symbol will be retained in the MathML expression. So an expression like `1 unitsml(mL)`
+will be recognised as referring to microlitres; the expression will be given under its canonical
+rendering `ml` in UnitsML markup, but the MathML rendering referencing that UnitsML expression
+will keep the notation `mL`.
+
+The symbols used for units can be highly ambiguous; in order to guarantee accurate parsing,
+the symbols used to data enter units are unambiguous in https://github.com/unitsml/unitsdb/units.yaml[units.yaml].
+They may be found as the entries for `unit_symbols/id` under each unit. For example, `B` is ambiguous between
+_bel_ (as in decibel) and _byte_; they are kept unambiguous by using `bel_B` and `byte_B` to refer to them,
+although they will still both be rendered as `B`.
+
+The following table is the current list of ambiguous symbols, which are disambiguated in the symbol ids used.
+This table can be generated (in Asciidoc format) through `Asciimath2UnitsML::Conv.new().ambig_units`:
+
+[cols="7*"]
+|===
+|Symbol | Unit + ID | | | | | 
+
 
+| &#8242; | minute (minute of arc): `'` | foot: `'_ft` | minute: `'_min` | minute (minute of arc): `prime` | foot: `prime_ft` | minute: `prime_min` 
+| &#8243; | second (second of arc): `"` | second: `"_s` | inch: `"_in` | second (second of arc): `dprime` | second: `dprime_s` | inch: `dprime_in` 
+| &#8243;Hg | conventional inch of mercury: `"Hg` | conventional inch of mercury: `dprime_Hg` | inch of mercury (32 degF): `"Hg_32degF` | inch of mercury (60 degF): `"Hg_60degF` | inch of mercury (32 degF): `dprime_Hg_32degF` | inch of mercury (60 degF): `dprime_Hg_60degF` 
+| hp | horsepower: `hp` | horsepower (UK): `hp_UK` | horsepower, water: `hp_water` | horsepower, metric: `hp_metric` | horsepower, boiler: `hp_boiler` | horsepower, electric: `hp_electric` 
+| Btu | British thermal unit_IT: `Btu` | British thermal unit (mean): `Btu_mean` | British thermal unit (39 degF): `Btu_39degF` | British thermal unit (59 degF): `Btu_59degF` | British thermal unit (60 degF): `Btu_60degF` | 
+| a | are: `a` | year (365 days): `a_year` | year, tropical: `a_tropical_year` | year, sidereal: `a_sidereal_year` | | 
+| d | day: `d` | darcy: `darcy` | day, sidereal: `d_sidereal` | | | 
+| inHg | conventional inch of mercury: `inHg` | inch of mercury (32 degF): `inHg_32degF` | inch of mercury (60 degF): `inHg_60degF` | | | 
+| inH~2~O | conventional inch of water: `inH_2O` | inch of water (39.2 degF): `inH_2O_39degF` | inch of water (60 degF): `inH_2O_60degF` | | | 
+| min | minute: `min` | minim: `minim` | minute, sidereal: `min_sidereal` | | | 
+| pc | parsec: `pc` | pica (printer's): `pica_printer` | pica (computer): `pica_computer` | | | 
+| t | metric ton: `t` | long ton: `ton_long` | short ton: `ton_short` | | | 
+| B | bel: `bel_B` | byte: `byte_B` | | | | 
+| cmHg | conventional centimeter of mercury: `cmHg` | centimeter of mercury (0 degC): `cmHg_0degC` | | | | 
+| cmH~2~O | conventional centimeter of water: `cmH_2O` | centimeter of water (4 degC): `cmH_2O_4degC` | | | | 
+| cup | cup (US): `cup` | cup (FDA): `cup_label` | | | | 
+| D | debye: `D` | darcy: `Darcy` | | | | 
+| ft | foot: `ft` | foot (based on US survey foot): `ft_US_survey` | | | | 
+| ftH~2~O | conventional foot of water: `ftH_2O` | foot of water (39.2 degF): `ftH_2O_39degF` | | | | 
+| gi | gill (US): `gi` | gill [Canadian and UK (Imperial)]: `gi_imperial` | | | | 
+| h | hour: `h` | hour, sidereal: `h_sidereal` | | | | 
+| &#8242;Hg | conventional foot of mercury: `'Hg` | conventional foot of mercury: `prime_Hg` | | | | 
+| __&#295;__ | natural unit of action: `h-bar` | atomic unit of action: `h-bar_atomic` | | | | 
+| __m__~e~ | natural unit of mass: `m_e` | atomic unit of mass: `m_e_atomic` | | | | 
+| in | inch: `in` | inch (based on US survey foot): `in_US_survey` | | | | 
+| K | kelvin: `K` | kayser: `kayser` | | | | 
+| L | liter: `L` | lambert: `Lambert` | | | | 
+| lb | pound (avoirdupois): `lb` | pound (troy or apothecary): `lb_troy` | | | | 
+| mi | mile: `mi` | mile (based on US survey foot): `mi_US_survey` | | | | 
+| mil | mil (length): `mil` | angular mil (NATO): `mil_nato` | | | | 
+| oz | ounce (avoirdupois): `oz` | ounce (troy or apothecary): `oz_troy` | | | | 
+| pt | point (printer's): `pt_printer` | point (computer): `pt_computer` | | | | 
+| rad | radian: `rad` | rad (absorbed dose): `rad_radiation` | | | | 
+| s | second: `s` | second, sidereal: `s_sidereal` | | | | 
+| tbsp | tablespoon: `tbsp` | tablespoon (FDA): `tbsp_label` | | | | 
+| ton | ton of TNT (energy equivalent): `ton_TNT` | ton of refrigeration (12 000 Btu_IT/h): `ton_refrigeration` | | | | 
+| tsp | teaspoon: `tsp` | teaspoon (FDA): `tsp_label` | | | | 
+| yd | yard: `yd` | yard (based on US survey foot): `yd_US_survey` | | | | 
+| &#186; | degree (degree of arc): `deg` | | | | | 
+| &#947; | gamma: `gamma` | | | | | 
+| &#956; | micron: `micron` | | | | | 
+| &#8486; | ohm: `Ohm` | | | | | 
+| &#197; | angstrom: `Aring` | | | | | 
+| &#295; | natural unit of action in eV s: `h-bar_eV_s` | | | | | 
+| ab&#937; | abohm: `abohm` | | | | | 
+| (ab&#937;)^-1^ | abmho: `abS` | | | | | 
+| aW | abwatt: `aW (Cardelli)` | | | | | 
+| b | barn: `barn` | | | | | 
+| Btu~th~ | British thermal unit_th: `Btu_th` | | | | | 
+| &#176;C | degree Celsius: `degC` | | | | | 
+| cal~IT~ | I.T. calorie: `cal_IT` | | | | | 
+| cal~th~ | thermochemical calorie: `cal_th` | | | | | 
+| &#176;F | degree Fahrenheit: `degF` | | | | | 
+| __a__~0~ | atomic unit of length: `a_0` | | | | | 
+| __c__ | natural unit of velocity: `c` | | | | | 
+| __c__~0~ | natural unit of velocity: `c_0` | | | | | 
+| __e__ | atomic unit of charge: `e` | | | | | 
+| __E__~h~ | atomic unit of energy: `e_h` | | | | | 
+| &#956;in | microinch: `uin` | | | | | 
+| &#176;K | kelvin: `degK` | | | | | 
+| kcal~IT~ | kilocalorie_IT: `kcal_IT` | | | | | 
+| kcal~th~ | kilocalorie_th: `kcal_th` | | | | | 
+| mmH~2~O | conventional millimeter of water: `mmH_2O` | | | | | 
+| &#176;R | degree Rankine: `degR` | | | | | 
+| &#x19b;~C~ | natural unit of length: `lambda-bar_C` | | | | | 
+|===

data/asciimath2unitsml.gemspec

@@ -1,5 +1,5 @@
 # coding: utf-8
-  
+
 lib = File.expand_path("../lib", __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require "asciimath2unitsml/version"
@@ -12,7 +12,7 @@ Gem::Specification.new do |spec|
 
   spec.summary       = "Convert Asciimath via MathML to UnitsML"
   spec.description   = <<~DESCRIPTION
-  Convert Asciimath via MathML to UnitsML
+    Convert Asciimath via MathML to UnitsML
   DESCRIPTION
 
   spec.homepage      = "https://github.com/plurimath/asciimath2unitsml"
@@ -24,6 +24,27 @@ Gem::Specification.new do |spec|
   spec.test_files    = `git ls-files -- {spec}/*`.split("\n")
   spec.required_ruby_version = Gem::Requirement.new(">= 2.4.0")
 
+  # get an array of submodule dirs relatively to root repo
+  `git config --file .gitmodules --get-regexp '\\.path$'`
+    .split("\n")
+    .map { |kv_str| kv_str.split(" ") }
+    .each do |(_, submodule_path)|
+
+      # for each submodule, change working directory to that submodule
+      Dir.chdir(submodule_path) do
+
+        # issue git ls-files in submodule's directory
+        submodule_files = `git ls-files | grep -i '.yaml$'`.split($\)
+
+        submodule_files_paths = submodule_files.map do |filename|
+          File.join submodule_path, filename
+        end
+
+        # add relative paths to gem.files
+        spec.files += submodule_files_paths
+      end
+  end
+
   spec.add_dependency "asciimath"
   spec.add_dependency "htmlentities"
   spec.add_dependency "nokogiri", "~> 1.10.4"
@@ -39,5 +60,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rubocop", "= 0.54.0"
   spec.add_development_dependency "simplecov", "~> 0.15"
   spec.add_development_dependency "timecop", "~> 0.9"
+  spec.add_development_dependency "rexml"
 end
 

data/lib/asciimath2unitsml.rb

@@ -1,3 +1,4 @@
 require_relative "asciimath2unitsml/version"
 require_relative "asciimath2unitsml/conv"
+require_relative "unitsdb_ruby/unitsdb"
 

data/lib/asciimath2unitsml/conv.rb

@@ -5,142 +5,52 @@ require "yaml"
 require "rsec"
 require_relative "string"
 require_relative "parse"
+require_relative "render"
+require_relative "unit"
 
 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)}")
+    def initialize(options = {})
+      @dimensions_id = read_yaml("../unitsdb/dimensions.yaml").each_with_object({}) do |(k, v), m|
+        m[k.to_s] = UnitsDB::Dimension.new(k, v)
       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'/>"
+      @prefixes_id = read_yaml("../unitsdb/prefixes.yaml").each_with_object({}) do |(k, v), m|
+        m[k] = UnitsDB::Prefix.new(k, v)
       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
+      @prefixes = flip_name_and_symbol(@prefixes_id)
+      @quantities = read_yaml("../unitsdb/quantities.yaml").each_with_object({}) do |(k, v), m|
+        m[k.to_s] = UnitsDB::Quantity.new(k, v)
+      end
+      @units_id = read_yaml("../unitsdb/units.yaml").each_with_object({}) do |(k, v), m|
+        m[k.to_s] = UnitsDB::Unit.new(k.to_s, v)
+      end
+      @units = flip_name_and_symbols(@units_id)
+      @symbols = @units.each_with_object({}) do |(k, v), m|
+        v.symbolids.each { |x| m[x] = v.symbols_hash[x] }
+      end
+      @parser = parser
+      @multiplier = multiplier(options[:multiplier] || "\u00b7")
     end
 
     def prefix(units)
-      units.map { |u| u[:prefix] }.reject { |u| u.nil? }.uniq.map do |p1|
-        p = p1.to_sym
+      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]}'>
-          <PrefixName xml:lang="en">#{@prefixes[p][:name]}</PrefixName>
-          <PrefixSymbol type="ASCII">#{@prefixes[p][:symbol]}</PrefixSymbol>
+        <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].ascii}</PrefixSymbol>
+          <PrefixSymbol type="unicode">#{@prefixes[p].unicode}</PrefixSymbol>
+          <PrefixSymbol type="LaTeX">#{@prefixes[p].latex}</PrefixSymbol>
+          <PrefixSymbol type="HTML">#{HTMLEntities.new.encode(@prefixes[p].html, :basic)}</PrefixSymbol>
         </Prefix>
         END
       end.join("\n")
     end
 
-    def dimension(dims)
+    def dimension_components(dims)
       return if dims.nil? || dims.empty?
       <<~END
       <Dimension xmlns='#{UNITSML_NS}' xml:id="#{dim_id(dims)}">
@@ -149,19 +59,8 @@ module Asciimath2UnitsML
       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)
+      norm = decompose_units(units)
       return if norm.any? { |u| u[:unit] == "unknown" || u[:prefix] == "unknown" }
       norm.map do |u|
         { dimension: U2D[u[:unit]][:dimension],
@@ -177,11 +76,16 @@ module Asciimath2UnitsML
 
     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("")
     end
 
-    def normalise_units(units)
-      gather_units(units.map { |u| normalise_unit(u) }.flatten)
+    def decompose_units(units)
+      gather_units(units_only(units).map { |u| decompose_unit(u) }.flatten)
     end
 
     def gather_units(units)
@@ -195,45 +99,79 @@ module Asciimath2UnitsML
       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] }
+    # 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
+      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].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) }
+        @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) }
         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]
+      return p1.symbolid if p2.nil?
+      return p2.symbolid 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]
+        return p.symbolid 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
+    def quantityname(id)
+      ret = ""
+      @quantities[id].names.each do |q|
+        ret += %(<QuantityName xml:lang="en-US">#{q}</QuantityName>)
+      end
+      ret
+    end
+
+    def quantity(normtext, quantity)
+      return unless @units[normtext] && @units[normtext].quantities.size == 1 || @quantities[quantity]
+      id = quantity || @units[normtext].quantities.first
+      dim = %( dimensionURL="##{@units[normtext].dimension}") if @units[normtext]&.dimension
+      <<~END
+      <Quantity xmlns='#{UNITSML_NS}' xml:id="#{id}"#{dim} quantityType="base">
+      #{quantityname(id)}
+      </Quantity>
+      END
+    end
+
+    def dimid2dimensions(normtext)
+      @dimensions_id[normtext].keys.map do |k|
+        { dimension: k,
+          symbol: U2D.values.select { |v| v[:dimension] == k }.first[:symbol],
+          exponent: @dimensions_id[normtext].exponent(k) }
       end
-      Rsec::Fail.reset
-      units
     end
 
-    def unitsml(units, text)
+    def dimension(normtext)
+      return unless @units[normtext]&.dimension 
+      dims = dimid2dimensions(@units[normtext]&.dimension)
+      <<~END
+      <Dimension xmlns='#{UNITSML_NS}' xml:id="#{@units[normtext]&.dimension}">
+      #{dims.map { |u| dimension1(u) }.join("\n") }
+      </Dimension>
+      END
+    end
+
+    def unitsml(units, origtext, normtext, quantity, name)
       dims = units2dimensions(units)
       <<~END
-      #{unit(units, text, dims)}
+      #{unit(units, origtext, normtext, dims, name)}
       #{prefix(units)}
-      #{dimension(dims)}
+      #{dimension(normtext)}
+      #{dimension_components(dims)}
+      #{quantity(normtext, quantity)}
       END
     end
   end