unitsml 0.3.0 → 0.4.1

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Unitsml
+  module Model
+    module Quantities
+      class Name < Lutaml::Model::Serializable
+        attribute :lang, :string, default: -> { "en-US" }
+        attribute :content, :string
+
+        xml do
+          root "QuantityName"
+
+          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/quantity.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "unitsml/model/quantities/name"
+
+module Unitsml
+  module Model
+    class Quantity < Lutaml::Model::Serializable
+      attribute :id, :string
+      attribute :name, Quantities::Name, collection: true
+      attribute :quantity_type, :string, default: -> { "base" }
+      attribute :dimension_url, :string
+
+      xml do
+        root "Quantity"
+        namespace Unitsml::UNITSML_NS
+
+        map_attribute :id, to: :id, namespace: nil, prefix: "xml"
+        map_attribute :quantityType, to: :quantity_type, render_default: true
+        map_attribute :dimensionURL, to: :dimension_url
+        map_element :QuantityName, to: :name
+      end
+    end
+  end
+end

data/lib/unitsml/model/unit.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "unitsml/model/units/name"
+require "unitsml/model/units/symbol"
+require "unitsml/model/units/system"
+require "unitsml/model/units/root_units"
+
+module Unitsml
+  module Model
+    class Unit < Lutaml::Model::Serializable
+      attribute :id, :string
+      attribute :name, Units::Name
+      attribute :dimension_url, :string
+      attribute :symbol, Units::Symbol, collection: true
+      attribute :system, Units::System, collection: true
+      attribute :root_units, Units::RootUnits
+
+      xml do
+        root "Unit"
+        namespace Unitsml::UNITSML_NS
+
+        map_attribute :dimensionURL, to: :dimension_url
+        map_attribute :id, to: :id, namespace: nil, prefix: "xml"
+        map_element :UnitSystem, to: :system
+        map_element :UnitName, to: :name
+        map_element :UnitSymbol, to: :symbol
+        map_element :RootUnits, to: :root_units
+      end
+    end
+  end
+end

data/lib/unitsml/model/units/enumerated_root_unit.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Unitsml
+  module Model
+    module Units
+      class EnumeratedRootUnit < Lutaml::Model::Serializable
+        attribute :unit, :string
+        attribute :prefix, :string
+        attribute :power_numerator, :string
+
+        xml do
+          map_attribute :unit, to: :unit
+          map_attribute :prefix, to: :prefix
+          map_attribute :powerNumerator, to: :power_numerator
+        end
+      end
+    end
+  end
+end

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

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

data/lib/unitsml/model/units/root_units.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "unitsml/model/units/enumerated_root_unit"
+
+module Unitsml
+  module Model
+    module Units
+      class RootUnits < Lutaml::Model::Serializable
+        attribute :enumerated_root_unit, EnumeratedRootUnit, collection: true
+
+        xml do
+          map_element :EnumeratedRootUnit, to: :enumerated_root_unit
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Unitsml
+  module Model
+    module Units
+      class Symbol < Lutaml::Model::Serializable
+        attribute :type, :string
+        attribute :content, :string
+
+        xml do
+          root "UnitSymbol"
+
+          map_attribute :type, to: :type
+          map_content to: :content, with: { from: :content_from_xml, to: :content_to_xml }
+        end
+
+        # Not reading any XML for now.
+        def content_from_xml(**); end
+
+        def content_to_xml(model, parent, doc)
+          doc.add_xml_fragment(parent, model.content)
+        end
+      end
+    end
+  end
+end

data/lib/unitsml/model/units/system.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Unitsml
+  module Model
+    module Units
+      class System < Lutaml::Model::Serializable
+        attribute :name, :string
+        attribute :type, :string
+        attribute :lang, :string, default: -> { "en-US" }
+
+        xml do
+          root "UnitSystem"
+
+          map_attribute :name, to: :name
+          map_attribute :type, to: :type
+          map_attribute :lang, to: :lang, namespace: nil, prefix: "xml", render_default: true
+        end
+      end
+    end
+  end
+end

data/lib/unitsml/parse.rb

@@ -1,11 +1,9 @@
 # frozen_string_literal: true
 
 require "parslet"
-require_relative "unitsdb"
+require "unitsml/unitsdb"
 module Unitsml
   class Parse < Parslet::Parser
-    include Unitsml::Unitsdb
-
     rule(:power)    { str("^") >> intermediate_exp(number) }
     rule(:hyphen)   { str("-") }
     rule(:number)   { (hyphen.maybe >> match(/[0-9]/).repeat(1)).as(:integer) }
@@ -14,19 +12,19 @@ module Unitsml
     rule(:unit_and_power) { units >> power.maybe }
 
     rule(:units) do
-      @@filtered_units ||= arr_to_expression(Unitsdb.filtered_units, "units")
+      @@filtered_units ||= arr_to_expression(Unitsdb.units.filtered, "units")
     end
 
     rule(:single_letter_prefixes) do
-      @@prefixes1 ||= arr_to_expression(Unitsdb.prefixes.select { |p| p.size == 1 }, "prefixes")
+      @@prefixes1 ||= arr_to_expression(Unitsdb.prefixes_by_size(1), "prefixes")
     end
 
     rule(:double_letter_prefixes) do
-      @@prefixes2 ||= arr_to_expression(Unitsdb.prefixes.select { |p| p.size == 2 }, "prefixes")
+      @@prefixes2 ||= arr_to_expression(Unitsdb.prefixes_by_size(2), "prefixes")
     end
 
     rule(:dimensions) do
-      @@dimensions ||= arr_to_expression(Unitsdb.parsable_dimensions.keys, "dimensions")
+      @@dimensions ||= arr_to_expression(Unitsdb.dimensions.parsables.keys, "dimensions")
     end
 
     rule(:prefixes_units) do

data/lib/unitsml/parser.rb

@@ -14,10 +14,10 @@ module Unitsml
 
     def parse
       nodes = Parse.new.parse(text)
+      transformed = Transform.new.apply(nodes)
+      formula_value = transformed.is_a?(Formula) ? transformed.value : Array(transformed)
       formula = Formula.new(
-        [
-          Transform.new.apply(nodes),
-        ],
+        formula_value,
         explicit_value: @extras_hash,
         root: true,
         orig_text: @orig_text,

data/lib/unitsml/prefix.rb

@@ -15,59 +15,59 @@ module Unitsml
         only_instance == object&.only_instance
     end
 
-    def id
-      Unitsdb.prefixes_hash.dig(prefix_name, :id)
+    def prefix_instance
+      @prefix ||= Unitsdb.prefixes.find_by_symbol_name(prefix_name)
     end
 
-    def name
-      fields.dig("name")
+    def id
+      @prefix.id
     end
 
-    def fields
-      Unitsdb.prefixes_hash.dig(prefix_name, :fields)
+    def name
+      prefix_instance.name
     end
 
     def prefixes_symbols
-      fields&.dig("symbol")
+      prefix_instance.symbol
     end
 
-    def to_mathml
+    def to_mathml(_)
       symbol = Utility.string_to_html_entity(
         Utility.html_entity_to_unicode(
-          prefixes_symbols["html"]
+          prefixes_symbols.html
         ),
       )
       return symbol unless only_instance
 
-      Utility.ox_element("mi") << symbol
+      { method_name: :mi, value: ::Mml::Mi.new(value: symbol)}
     end
 
-    def to_latex
-      prefixes_symbols["latex"]
+    def to_latex(_)
+      prefixes_symbols.latex
     end
 
-    def to_asciimath
-      prefixes_symbols["ascii"]
+    def to_asciimath(_)
+      prefixes_symbols.ascii
     end
 
-    def to_html
-      prefixes_symbols["html"]
+    def to_html(_)
+      prefixes_symbols.html
     end
 
-    def to_unicode
-      prefixes_symbols["unicode"]
+    def to_unicode(_)
+      prefixes_symbols.unicode
     end
 
     def symbolid
-      prefixes_symbols["ascii"] if prefixes_symbols
+      prefixes_symbols.ascii if prefixes_symbols
     end
 
     def base
-      fields&.dig("base")
+      prefix_instance.base
     end
 
     def power
-      fields&.dig("power")
+      prefix_instance.power
     end
   end
 end

data/lib/unitsml/sqrt.rb

@@ -13,24 +13,24 @@ module Unitsml
         value == object&.value
     end
 
-    def to_asciimath
-      value&.to_asciimath
+    def to_asciimath(options)
+      value&.to_asciimath(options)
     end
 
-    def to_latex
-      value&.to_latex
+    def to_latex(options)
+      value&.to_latex(options)
     end
 
-    def to_mathml
-      value&.to_mathml
+    def to_mathml(options)
+      value&.to_mathml(options)
     end
 
-    def to_html
-      value&.to_html
+    def to_html(options)
+      value&.to_html(options)
     end
 
-    def to_unicode
-      value.to_unicode
+    def to_unicode(options)
+      value&.to_unicode(options)
     end
   end
 end

data/lib/unitsml/unit.rb

@@ -19,77 +19,77 @@ module Unitsml
         power_numerator == object&.power_numerator
     end
 
-    def fields_hash
-      Unitsdb.units.dig(unit_name, :fields)
+    def unit_instance
+      Unitsdb.units.find_by_name(unit_name)
     end
 
     def unit_symbols
-      symbols = fields_hash.dig("unit_symbols")
-      symbols.find{|symbol| symbol["id"] == unit_name }
+      unit_instance.unit_symbols.find { |symbol| symbol.id == unit_name }
     end
 
     def numerator_value(mathml = true)
       integer = power_numerator.to_s
       unless integer.match?(/-/)
-        return mathml ? [Ox.parse("<mn>#{integer}</mn>")] : integer
+        return mathml ? { mn_value: [::Mml::Mn.from_xml("<mn>#{integer}</mn>")] } : integer
       end
 
       return integer.sub(/(-)(.+)/, '&#x2212;\2') unless mathml
 
       integer = integer.sub(/(-)(.+)/, '<mn>\2</mn>')
-      integer = Ox.parse(integer)
-      mo_tag = (Utility.ox_element("mo") << "&#x2212;")
-      [mo_tag, integer]
+      integer = ::Mml::Mn.from_xml(integer)
+      mo_tag = ::Mml::Mo.new(value: "&#x2212;")
+      { mo_value: [mo_tag], mn_value: [integer] }
     end
 
-    def to_mathml
-      value = unit_symbols&.dig("mathml")
-      value = Ox.parse(value)
-      value.nodes.insert(0, prefix.to_mathml) if prefix
+    def to_mathml(options)
+      value = unit_symbols&.mathml
+      tag_name = value.match(/^<(?<tag>\w+)/)[:tag]
+      value = ::Mml.const_get(tag_name.capitalize).from_xml(value)
+      value.value = "#{prefix.to_mathml(options)}#{value.value}" if prefix
       if power_numerator
-        msup = Utility.ox_element("msup")
-        msup << (Utility.ox_element("mrow") << value)
-        msup << Utility.update_nodes(
-          Utility.ox_element("mrow"),
-          numerator_value,
+        value = ::Mml::Msup.new(
+          mrow_value: [
+            ::Mml::Mrow.new("#{tag_name}_value": Array(value)),
+            ::Mml::Mrow.new(numerator_value),
+          ]
         )
-        value = msup
+        tag_name = :msup
       end
-      value
+      { method_name: tag_name.to_sym, value: value }
     end
 
-    def to_latex
-      value = unit_symbols&.dig("latex")
+    def to_latex(options)
+      value = unit_symbols&.latex
       value = "#{value}^#{power_numerator}" if power_numerator
-      value = "#{prefix.to_latex}#{value}" if prefix
+      value = "#{prefix.to_latex(options)}#{value}" if prefix
       value
     end
 
-    def to_asciimath
-      value = unit_symbols&.dig("ascii")
+    def to_asciimath(options)
+      value = unit_symbols&.ascii
       value = "#{value}^#{power_numerator}" if power_numerator
-      value = "#{prefix.to_asciimath}#{value}" if prefix
+      value = "#{prefix.to_asciimath(options)}#{value}" if prefix
       value
     end
 
-    def to_html
-      value = unit_symbols&.dig("html")
+    def to_html(options)
+      value = unit_symbols&.html
       if power_numerator
         value = "#{value}<sup>#{numerator_value(false)}</sup>"
       end
-      value = "#{prefix.to_html}#{value}" if prefix
+      value = "#{prefix.to_html(options)}#{value}" if prefix
       value
     end
 
-    def to_unicode
-      value = unit_symbols&.dig("unicode")
+    def to_unicode(options)
+      value = unit_symbols&.unicode
       value = "#{value}^#{power_numerator}" if power_numerator
-      value = "#{prefix.to_unicode}#{value}" if prefix
+      value = "#{prefix.to_unicode(options)}#{value}" if prefix
       value
     end
 
     def enumerated_name
-      fields_hash.dig("unit_name")&.first
+      unit_instance&.unit_name&.first
     end
 
     def prefix_name
@@ -97,15 +97,15 @@ module Unitsml
     end
 
     def system_type
-      fields_hash.dig("unit_system", "type")
+      unit_instance.unit_system.type
     end
 
     def system_name
-      fields_hash.dig("unit_system", "name")
+      unit_instance.unit_system.name
     end
 
     def si_derived_bases
-      fields_hash.dig("si_derived_bases")
+      unit_instance.si_derived_bases
     end
   end
 end

data/lib/unitsml/unitsdb/dimension.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Unitsml
+  module Unitsdb
+    class Dimension
+      attr_accessor :vector,
+                    :id,
+                    :dimensionless
+
+      attr_reader :length,
+                  :mass,
+                  :time,
+                  :electric_current,
+                  :thermodynamic_temperature,
+                  :amount_of_substance,
+                  :luminous_intensity,
+                  :plane_angle,
+                  :parsables,
+                  :parsable,
+                  :processed_keys
+
+      def initialize
+        @parsables = {}
+        @processed_keys = []
+        @parsable = false
+      end
+
+      def length=(value)
+        quantities_common_code(:length, value)
+      end
+
+      def mass=(value)
+        quantities_common_code(:mass, value)
+      end
+
+      def time=(value)
+        quantities_common_code(:time, value)
+      end
+
+      def thermodynamic_temperature=(value)
+        quantities_common_code(:thermodynamic_temperature, value)
+      end
+
+      def amount_of_substance=(value)
+        quantities_common_code(:amount_of_substance, value)
+      end
+
+      def luminous_intensity=(value)
+        quantities_common_code(:luminous_intensity, value)
+      end
+
+      def plane_angle=(value)
+        quantities_common_code(:plane_angle, value)
+      end
+
+      def electric_current=(value)
+        quantities_common_code(:electric_current, value)
+      end
+
+      def dim_symbols
+        processed_keys.map { |vec| public_send(vec)&.dim_symbols&.map(&:id) }.flatten.compact
+      end
+
+      def processed_symbol
+        public_send(processed_keys.first).symbol
+      end
+
+      def set_vector
+        @vector ||= Utility::DIMS_VECTOR.map do |h|
+          public_send(Utility.underscore(h))&.power_numerator
+        end.join(":")
+      end
+
+      private
+
+      def quantities_common_code(instance_var, value)
+        return if value.nil?
+
+        instance_variable_set(:"@#{instance_var}", value)
+        @processed_keys << instance_var.to_s
+        return if value.dim_symbols.empty?
+
+        @parsable = true
+        value.dim_symbols_ids(@parsables, id)
+      end
+    end
+  end
+end

data/lib/unitsml/unitsdb/dimension_quantity.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Unitsml
+  module Unitsdb
+    class DimensionQuantity
+      attr_accessor :power_numerator,
+                    :symbol,
+                    :dim_symbols
+
+      def dim_symbols_ids(hash, dim_id)
+        dim_symbols.each { |dim_sym| hash[dim_sym.id] = dim_id }
+      end
+    end
+  end
+end

data/lib/unitsml/unitsdb/dimensions.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Unitsml
+  module Unitsdb
+    class Dimensions
+      attr_accessor :dimensions
+
+      def find_by_vector(vector)
+        vectored
+        find(:vector, vector)
+      end
+
+      def find_by_id(d_id)
+        find(:id, d_id)
+      end
+
+      def find_parsables_by_id(d_id)
+        find(:id, parsables[d_id])
+      end
+
+      def parsables
+        @parsables ||= dimensions.select(&:parsables).each_with_object({}) do |dimension, object|
+          object.merge!(dimension.parsables)
+        end
+      end
+
+      private
+
+      def vectored
+        @vectored ||= dimensions.each(&:set_vector)
+      end
+
+      def find(field, matching_data)
+        dimensions.find { |dim| dim.send(field) == matching_data }
+      end
+    end
+  end
+end

data/lib/unitsml/unitsdb/prefixes.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Unitsml
+  module Unitsdb
+    class Prefixes
+      attr_accessor :prefixes
+
+      def find_by_symbol_name(ascii_sym)
+        prefixes.find { |prefix| prefix.symbol.ascii == ascii_sym }
+      end
+
+      def ascii_symbols
+        prefixes.each_with_object([]) do |prefix, names_array|
+          symbol = prefix.symbol.ascii
+          next if symbol.empty?
+
+          names_array << symbol
+        end
+      end
+    end
+  end
+end

data/lib/unitsml/unitsdb/quantities.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Unitsml
+  module Unitsdb
+    class Quantities
+      attr_accessor :quantities
+
+      def find_by_id(q_id)
+        quantities.find { |quantity| quantity.id == q_id }
+      end
+    end
+  end
+end