unitsml 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5eec8700e144a7983623483da1e4093d961a717e0344f429ec03687257f1450f
-  data.tar.gz: 40b736d843d780c4b1366b11eb1441cbc53ba611f16507a33482b3f1c702ed7c
+  metadata.gz: fc35634600e24763c82ac222f83b7d5ac33579d6a0d9f34db20b7be152a106f0
+  data.tar.gz: a19876a30635b3df9282066f455688bf5291b6195d6cee9430fc149be7ba5c86
 SHA512:
-  metadata.gz: b14c95f4aaa4c223138212b82e082e42b5ae5d86689d4186d657f8b97dc9c8553b171c14cf08b386c930dae4ac2532400ecb286b9624a36c8e29a4fb8d8d6c10
-  data.tar.gz: cc1a2a790ae2084763eddda110f3fd7a3425d3cf8ae93c65649b7496e4f6fa6c4a52c856bee4bbc2e436ca09aff9a3ce852316ba7407dffea9949a763b4af0f6
+  metadata.gz: 21e89ee185da0df863ddb5b6f7aa7ea8584eed0077fe5275b4a8d7e8b27444fdcdc69f89962ab32460e5ec8652f91c07e731988d4a44291817806f6a0ed8d93a
+  data.tar.gz: 8b83f0cfc7175f663637b4816367b330a4b692690fcd92f612537b0df68e2f2efb7231751e2998ad9a63b41a692659fdf858ab3b95cc030a9b22e6fa980fd773

data/.github/workflows/dependent-repos.json

@@ -0,0 +1,5 @@
+{
+  "repo": [
+    "plurimath/plurimath"
+  ]
+}

data/.github/workflows/depenedent-gems.yml

@@ -0,0 +1,16 @@
+name: dependent-gems-test
+
+on:
+  push:
+    branches: [ main ]
+    tags: [ v* ]
+  pull_request:
+  workflow_dispatch:
+  repository_dispatch:
+    types: [ release-passed ]
+
+jobs:
+  rake:
+    uses: metanorma/ci/.github/workflows/dependent-rake.yml@main
+    with:
+      command: bundle exec rspec

data/Gemfile

@@ -6,6 +6,7 @@ gemspec
 gem "byebug"
 gem "equivalent-xml"
 gem "oga"
+gem "ox"
 gem "plurimath"
 gem "pry"
 gem "rake"

data/lib/unitsml/dimension.rb

@@ -15,53 +15,46 @@ module Unitsml
         power_numerator == object&.power_numerator
     end
 
-    def dim_hash
-      Unitsdb.parsable_dimensions[dimension_name]
+    def dim_instance
+      @dim ||= Unitsdb.dimensions.find_parsables_by_id(dimension_name)
     end
 
     def dim_symbols
-      dim_hash&.values&.last&.values&.first["dim_symbols"].first
+      dim_instance.send(@dim.processed_keys.last).dim_symbols.first
     end
 
-    def to_mathml
-      value = dim_symbols["mathml"]
-      value = Ox.parse(value)
+    def to_mathml(_)
+      # MathML key's value in unitsdb/dimensions.yaml file includes mi tags only.
+      value = ::Mml::Mi.from_xml(dim_symbols.mathml)
+      method_name = power_numerator ? :msup : :mi
       if power_numerator
-        msup = Utility.ox_element("msup")
-        msup << (Utility.ox_element("mrow") << value)
-        msup << (
-          Utility.ox_element("mrow") << (
-            Utility.ox_element("mn") << power_numerator
-          )
+        value = ::Mml::Msup.new(
+          mrow_value: [
+            ::Mml::Mrow.new(mi_value: [value]),
+            ::Mml::Mrow.new(
+              mn_value: [::Mml::Mn.new(value: power_numerator)],
+            ),
+          ]
         )
-        value = msup
       end
-      value
+      { method_name: method_name, value: value }
     end
 
-    def to_latex
-      value = dim_symbols["latex"]
-      if power_numerator
-        value = "#{value}^#{power_numerator}"
-      end
-      value
+    def to_latex(_)
+      power_numerator_generic_code(:latex)
     end
 
-    def to_asciimath
-      value = dim_symbols["ascii"]
-      value = "#{value}^#{power_numerator}" if power_numerator
-      value
+    def to_asciimath(_)
+      power_numerator_generic_code(:ascii)
     end
 
-    def to_html
-      value = dim_symbols["html"]
-      value = "#{value}<sup>#{power_numerator}</sup>" if power_numerator
-      value
+    def to_unicode(_)
+      power_numerator_generic_code(:unicode)
     end
 
-    def to_unicode
-      value = dim_symbols["unicode"]
-      value = "#{value}^#{power_numerator}" if power_numerator
+    def to_html(_)
+      value = dim_symbols.html
+      value = "#{value}<sup>#{power_numerator}</sup>" if power_numerator
       value
     end
 
@@ -69,17 +62,33 @@ module Unitsml
       "#{dimension_name.split('_').last}#{power_numerator}"
     end
 
-    def to_xml
-      fields = dim_hash[:fields]
-      symbol = fields.values.first["symbol"]
-      power_numerator_value = power_numerator || 1
-      attributes = { symbol: symbol, powerNumerator: power_numerator_value }
-      element_name = modelize(fields.keys.first.capitalize)
-      Utility.ox_element(element_name, attributes: attributes)
+    def to_xml(_)
+      attributes = {
+        symbol: dim_instance.processed_symbol,
+        power_numerator: power_numerator || 1,
+      }
+      Model::DimensionQuantities.const_get(modelize(element_name)).new(attributes)
+    end
+
+    def xml_instances_hash(options)
+      { element_name => to_xml(options) }
     end
 
     def modelize(value)
       value&.split("_")&.map(&:capitalize)&.join
     end
+
+    private
+
+    def power_numerator_generic_code(method_name)
+      value = dim_symbols.public_send(method_name)
+      return value unless power_numerator
+
+      "#{value}^#{power_numerator}"
+    end
+
+    def element_name
+      dim_instance.processed_keys.first
+    end
   end
 end

data/lib/unitsml/extender.rb

@@ -13,24 +13,38 @@ module Unitsml
         symbol == object&.symbol
     end
 
-    def to_mathml
-      Utility.ox_element("mo") << "&#x22c5;"
+    def to_mathml(options)
+      multiplier = case options[:multiplier]
+                   when :space
+                     rspace = "thickmathspace"
+                     "&#x2062;"
+                   when :nospace
+                     "&#x2062;"
+                   else
+                     extender = options[:multiplier] || "⋅"
+                     Utility.string_to_html_entity(extender)
+                   end
+      {
+        method_name: :mo,
+        value: ::Mml::Mo.new(value: multiplier, rspace: rspace),
+      }
     end
 
-    def to_latex
-      "/"
+    def to_latex(options)
+      options[:multiplier] || "/"
     end
 
-    def to_asciimath
-      symbol
+    def to_asciimath(options)
+      options[:multiplier] || symbol
     end
 
-    def to_html
-      "&#x22c5;"
+    def to_html(options)
+      options[:multiplier] || "&#x22c5;"
     end
 
-    def to_unicode
-      symbol == "*" ? "·" : symbol
+    def to_unicode(options)
+      options[:multiplier] ||
+        symbol == "*" ? "·" : symbol
     end
   end
 end

data/lib/unitsml/formula.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
-require_relative "utility"
+require "mml"
+require "htmlentities"
+require "unitsml/utility"
 module Unitsml
   class Formula
     attr_accessor :value, :explicit_value, :root
@@ -24,61 +26,68 @@ module Unitsml
         root == object.root
     end
 
-    def to_mathml
+    def to_mathml(options = {})
       if root
-        attributes = { xmlns: "http://www.w3.org/1998/Math/MathML", display: "block" }
-        math = Utility.ox_element("math", attributes: attributes)
-        Ox.dump(
-          Utility.update_nodes(
-            math,
-            value.map(&:to_mathml).flatten,
-          ),
-        ).gsub(/&amp;(.*?)(?=<\/)/, '&\1')
+        update_options(options)
+        nullify_mml_models if plurimath_available?
+        math = ::Mml::MathWithNamespace.new(display: "block")
+        math.ordered = true
+        math.element_order ||= []
+        value.each do |instance|
+          processed_instance = instance.to_mathml(options)
+          case processed_instance
+          when Array
+            processed_instance.each { |hash| add_math_element(math, hash) }
+          when Hash
+            add_math_element(math, processed_instance)
+          end
+        end
+        reset_mml_models if plurimath_available?
+        math.to_xml.gsub(/&amp;(.*?)(?=<\/)/, '&\1')
       else
-        value.map(&:to_mathml)
+        value.map { |obj| obj.to_mathml(options) }
       end
     end
 
-    def to_latex
-      value.map(&:to_latex).join
+    def to_latex(options = {})
+      value.map { |obj| obj.to_latex(update_options(options)) }.join
     end
 
-    def to_asciimath
-      value.map(&:to_asciimath).join
+    def to_asciimath(options = {})
+      value.map { |obj| obj.to_asciimath(update_options(options)) }.join
     end
 
-    def to_html
-      value.map(&:to_html).join
+    def to_html(options = {})
+      value.map { |obj| obj.to_html(update_options(options)) }.join
     end
 
-    def to_unicode
-      value.map(&:to_unicode).join
+    def to_unicode(options = {})
+      value.map { |obj| obj.to_unicode(update_options(options)) }.join
     end
 
-    def to_xml
-      dimensions_array = extract_dimensions(value)
-      if (dimensions_array).any?
-        dimensions(sort_dims(dimensions_array))
+    def to_xml(options = {})
+      update_options(options)
+      if (dimensions_array = extract_dimensions(value)).any?
+        dimensions(sort_dims(dimensions_array), options)
       elsif @orig_text.match(/-$/)
-        prefixes
+        prefixes(options)
       else
-        units
+        units(options)
       end
     end
 
-    def to_plurimath
+    def to_plurimath(options = {})
       ensure_plurimath_defined!
-      return Plurimath::Math.parse(to_asciimath, :asciimath) if @orig_text.match?(/-$/)
+      options = update_options(options)
+      return Plurimath::Math.parse(to_asciimath(options), :asciimath) if @orig_text.match?(/-$/)
 
-      Plurimath::Math.parse(to_mathml, :mathml)
+      Plurimath::Math.parse(to_mathml(options), :mathml)
     end
 
     private
 
     def extract_dimensions(formula)
-      dimensions = []
-
-      formula.each do |term|
+      formula.each_with_object([]) do |term, dimensions|
         if term.is_a?(Dimension)
           dimensions << term
         elsif term.is_a?(Sqrt) && term.value.is_a?(Dimension)
@@ -89,14 +98,10 @@ module Unitsml
           dimensions.concat(extract_dimensions(term.value))
         end
       end
-
-      dimensions
     end
 
     def extract_units(formula)
-      units_arr = []
-
-      formula.each do |term|
+      formula.each_with_object([]) do |term, units_arr|
         case term
         when Unit
           units_arr << term.dup
@@ -108,20 +113,16 @@ module Unitsml
           units_arr << term.value
         end
       end
-
-      units_arr
     end
 
-    def units
+    def units(options)
       all_units = extract_units(value)
       norm_text = Utility.postprocess_normtext(all_units)
       dims = Utility.units2dimensions(extract_units(value))
-      dimension, dimension_component = unique_dimensions(dims, norm_text)
       [
-        Utility.unit(all_units, self, dims, norm_text, explicit_value&.dig(:name)),
-        Utility.prefixes(all_units),
-        dimension,
-        dimension_component,
+        Utility.unit(all_units, self, dims, norm_text, explicit_value&.dig(:name), options),
+        Utility.prefixes(all_units, options),
+        *unique_dimensions(dims, norm_text),
         Utility.quantity(norm_text, explicit_value&.dig(:quantity)),
       ].join
     end
@@ -133,15 +134,11 @@ module Unitsml
       ].uniq
     end
 
-    def dimensions(dims)
+    def dimensions(dims, options)
       dim_id = dims.map(&:generate_id).join
-      attributes = { xmlns: Utility::UNITSML_NS, "xml:id": "D_#{dim_id}" }
-      Ox.dump(
-        Utility.update_nodes(
-          Utility.ox_element("Dimension", attributes: attributes),
-          dims.map(&:to_xml),
-        ),
-      )
+      attributes = { id: "D_#{dim_id}" }
+      dims.each { |dim| attributes.merge!(dim.xml_instances_hash(options)) }
+      Model::Dimension.new(attributes).to_xml
     end
 
     def sort_dims(values)
@@ -151,22 +148,49 @@ module Unitsml
       end
     end
 
-    def prefixes
+    def prefixes(options)
       norm_text = @norm_text&.split("-")&.first
       prefix_object = Unit.new("", prefix: Prefix.new(norm_text))
       [
-        Utility.prefixes([prefix_object]),
+        Utility.prefixes([prefix_object], options),
         Utility.dimension(norm_text),
         Utility.quantity(norm_text, explicit_value&.dig(:quantity)),
       ].join
     end
 
     def ensure_plurimath_defined!
-      return if Object.const_defined?(:Plurimath)
+      return if plurimath_available?
 
       require "plurimath"
     rescue LoadError => e
       raise Errors::PlurimathLoadError
     end
+
+    def add_math_element(math_instance, child_hash)
+      method_name = child_hash[:method_name]
+      method_value = math_instance.public_send(:"#{method_name}_value")
+      method_value += Array(child_hash[:value])
+      math_instance.public_send(:"#{method_name}_value=", method_value)
+      math_instance.element_order << Lutaml::Model::XmlAdapter::Element.new("Element", method_name.to_s)
+    end
+
+    def plurimath_available?
+      Object.const_defined?(:Plurimath)
+    end
+
+    def nullify_mml_models
+      Plurimath::Mathml::Parser::CONFIGURATION.each_key { |klass| klass.model(klass) }
+    end
+
+    def reset_mml_models
+      ::Mml::Configuration.custom_models = Plurimath::Mathml::Parser::CONFIGURATION
+    end
+
+    def update_options(options)
+      return options unless root
+
+      multiplier = options[:multiplier] || explicit_value&.dig(:multiplier)
+      options.merge(multiplier: multiplier).compact
+    end
   end
 end

data/lib/unitsml/model/dimension.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "unitsml/model/dimension_quantities/quantity"
+require "unitsml/model/dimension_quantities/length"
+require "unitsml/model/dimension_quantities/mass"
+require "unitsml/model/dimension_quantities/time"
+require "unitsml/model/dimension_quantities/electric_current"
+require "unitsml/model/dimension_quantities/thermodynamic_temperature"
+require "unitsml/model/dimension_quantities/amount_of_substance"
+require "unitsml/model/dimension_quantities/luminous_intensity"
+require "unitsml/model/dimension_quantities/plane_angle"
+
+module Unitsml
+  module Model
+    class Dimension < Lutaml::Model::Serializable
+      attribute :id, :string
+      attribute :length, DimensionQuantities::Length
+      attribute :mass, DimensionQuantities::Mass
+      attribute :time, DimensionQuantities::Time
+      attribute :electric_current, DimensionQuantities::ElectricCurrent
+      attribute :thermodynamic_temperature, DimensionQuantities::ThermodynamicTemperature
+      attribute :amount_of_substance, DimensionQuantities::AmountOfSubstance
+      attribute :luminous_intensity, DimensionQuantities::LuminousIntensity
+      attribute :plane_angle, DimensionQuantities::PlaneAngle
+
+      xml do
+        root "Dimension"
+        namespace Unitsml::UNITSML_NS
+
+        map_attribute :id, to: :id, namespace: nil, prefix: "xml"
+        map_element :Length, to: :length
+        map_element :Mass, to: :mass
+        map_element :Time, to: :time
+        map_element :ElectricCurrent, to: :electric_current
+        map_element :ThermodynamicTemperature, to: :thermodynamic_temperature
+        map_element :AmountOfSubstance, to: :amount_of_substance
+        map_element :LuminousIntensity, to: :luminous_intensity
+        map_element :PlaneAngle, to: :plane_angle
+      end
+    end
+  end
+end

data/lib/unitsml/model/dimension_quantities/amount_of_substance.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Unitsml
+  module Model
+    module DimensionQuantities
+      class AmountOfSubstance < Quantity
+      end
+    end
+  end
+end

data/lib/unitsml/model/dimension_quantities/electric_current.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Unitsml
+  module Model
+    module DimensionQuantities
+      class ElectricCurrent < Quantity
+      end
+    end
+  end
+end

data/lib/unitsml/model/dimension_quantities/length.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Unitsml
+  module Model
+    module DimensionQuantities
+      class Length < Quantity
+      end
+    end
+  end
+end

data/lib/unitsml/model/dimension_quantities/luminous_intensity.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Unitsml
+  module Model
+    module DimensionQuantities
+      class LuminousIntensity < Quantity
+      end
+    end
+  end
+end

data/lib/unitsml/model/dimension_quantities/mass.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Unitsml
+  module Model
+    module DimensionQuantities
+      class Mass < Quantity
+      end
+    end
+  end
+end

data/lib/unitsml/model/dimension_quantities/plane_angle.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Unitsml
+  module Model
+    module DimensionQuantities
+      class PlaneAngle < Quantity
+      end
+    end
+  end
+end

data/lib/unitsml/model/dimension_quantities/quantity.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Unitsml
+  module Model
+    module DimensionQuantities
+      class Quantity < Lutaml::Model::Serializable
+        attribute :symbol, :string
+        attribute :power_numerator, :string
+
+        xml do
+          map_attribute :symbol, to: :symbol
+          map_attribute :powerNumerator, to: :power_numerator
+        end
+      end
+    end
+  end
+end

data/lib/unitsml/model/dimension_quantities/thermodynamic_temperature.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Unitsml
+  module Model
+    module DimensionQuantities
+      class ThermodynamicTemperature < Quantity
+      end
+    end
+  end
+end

data/lib/unitsml/model/dimension_quantities/time.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Unitsml
+  module Model
+    module DimensionQuantities
+      class Time < Quantity
+      end
+    end
+  end
+end

data/lib/unitsml/model/prefix.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "unitsml/model/prefixes/name"
+require "unitsml/model/prefixes/symbol"
+
+
+module Unitsml
+  module Model
+    class Prefix < Lutaml::Model::Serializable
+      attribute :name, Prefixes::Name
+      attribute :id, :string
+      attribute :symbol, Prefixes::Symbol, collection: true
+      attribute :prefix_base, :string
+      attribute :prefix_power, :string
+
+      xml do
+        root "Prefix"
+        namespace Unitsml::UNITSML_NS
+
+        map_attribute :prefixBase, to: :prefix_base
+        map_attribute :prefixPower, to: :prefix_power
+        map_attribute :id, to: :id, namespace: nil, prefix: "xml"
+        map_element :PrefixName, to: :name
+        map_element :PrefixSymbol, to: :symbol
+      end
+    end
+  end
+end

data/lib/unitsml/model/prefixes/name.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Unitsml
+  module Model
+    class Prefixes
+      class Name < Lutaml::Model::Serializable
+        attribute :lang, :string, default: -> { "en" }
+        attribute :content, :string
+
+        xml do
+          root "PrefixName"
+
+          map_attribute :lang, to: :lang, namespace: nil, prefix: "xml", render_default: true
+          map_content to: :content
+        end
+      end
+    end
+  end
+end

data/lib/unitsml/model/prefixes/symbol.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Unitsml
+  module Model
+    class Prefixes
+      class Symbol < Lutaml::Model::Serializable
+        attribute :type, :string
+        attribute :content, :string
+
+        xml do
+          root "PrefixSymbol"
+
+          map_attribute :type, to: :type
+          map_content to: :content
+        end
+      end
+    end
+  end
+end