unitsml 0.2.9 → 0.4.0

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

data/lib/unitsml/unitsdb/units.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Unitsml
+  module Unitsdb
+    class Units
+      attr_accessor :units
+
+      def find_by_id(u_id)
+        units.find { |unit| unit.id == u_id }
+      end
+
+      def find_by_name(u_name)
+        units.find do |unit|
+          unit.unit_symbols.find { |u_sym| u_sym.id == u_name }
+        end
+      end
+
+      def filtered
+        @filtered ||= units_symbol_ids.reject do |unit|
+          ((/\*|\^|\/|^1$/).match?(unit) || find_by_symbol_id(unit).prefixed)
+        end
+      end
+
+      def find_by_symbol_id(sym_id)
+        units_symbol_hash[sym_id]
+      end
+
+      def units_symbol_ids
+        units_symbol_hash.keys
+      end
+
+      def units_symbol_hash
+        @symbol_ids_hash ||= {}
+
+        if @symbol_ids_hash.empty?
+          units.each_with_object(@symbol_ids_hash) do |unit, object|
+            unit.unit_symbols.each { |unit_sym| object[unit_sym.id] = unit }
+          end
+        end
+        @symbol_ids_hash
+      end
+    end
+  end
+end

data/lib/unitsml/unitsdb.rb

@@ -1,96 +1,38 @@
 # frozen_string_literal: true
 
-require "yaml"
 module Unitsml
   module Unitsdb
     class << self
-      def load_yaml(file_name)
+      def load_file(file_name)
         @@hash ||= {}
-        @@hash[file_name] ||= YAML.load_file(valid_path(file_name))
-      end
-
-      def load_dimensions
-        @@dim_file = load_yaml(:dimensions)
-      end
-
-      def load_units
-        @@units_file = load_yaml(:units)
+        @@hash[file_name] ||= File.read(valid_path(file_name))
       end
 
       def units
-        @@units ||= {}
-        return @@units unless @@units.empty?
-
-        load_units.each do |key, value|
-          value["unit_symbols"]&.each do |symbol|
-            @@units[symbol["id"]] = { id: key, fields: value } unless symbol["id"]&.empty?
-          end
-        end
-        @@units
+        @@units_file ||= ::Unitsdb::Units.from_yaml(load_file((:units)))
       end
 
       def prefixes
-        @@prefixes_array ||= prefixes_hash.keys.sort_by(&:length)
+        @@prefixes ||= ::Unitsdb::Prefixes.from_yaml(load_file(:prefixes))
       end
 
-      def parsable_dimensions
-        @@parsable_dimensions ||= {}
-        return @@parsable_dimensions unless @@parsable_dimensions.empty?
-
-        dimensions_hash.each do |key, value|
-          value.each do |_, v|
-            @@parsable_dimensions[find_id(v)] = { id: key, fields: value }
-          end
-        end
-        @@parsable_dimensions
+      def dimensions
+        @@dim_file ||= ::Unitsdb::Dimensions.from_yaml(load_file(:dimensions))
       end
 
       def quantities
-        @@quantities ||= load_yaml(:quantities)
-      end
-
-      def filtered_units
-        @@filtered_units_array ||= units.keys.reject do |unit|
-          ((/\*|\^|\/|^1$/).match?(unit) || units.dig(unit, :fields, "prefixed"))
-        end
-      end
-
-      def prefixes_hash
-        @@prefixes_hashes ||= prefixs_ids(load_yaml(:prefixes))
-      end
-
-      def dimensions_hash
-        @@dimensions_hashs ||= insert_vectors(load_dimensions)
+        @@quantities ||= ::Unitsdb::Quantities.from_yaml(load_file((:quantities)))
       end
 
-      def prefixs_ids(prefixe_hash, hash = {})
-        prefixe_hash&.each do |key, value|
-          symbol = value&.dig("symbol", "ascii")
-          hash[symbol] = { id: key, fields: value } unless symbol&.empty?
-        end
-        hash
+      def prefixes_array
+        @@prefixes_array ||= prefixes.ascii_symbols.sort_by(&:length)
       end
 
-      def find_id(value)
-        return if value == true
-        return unless value.is_a?(Hash)
-
-        value&.dig("dim_symbols")&.map { |symbol| symbol&.dig("id") }&.first
-      end
-
-      def vector(dim_hash)
-        Utility::DIMS_VECTOR.map { |h| dim_hash.dig(underscore(h), "powerNumerator") }.join(":")
-      end
-
-      def underscore(str)
-        str.gsub(/([a-z])([A-Z])/, '\1_\2').downcase
-      end
+      def prefixes_by_size(size)
+        @@sized_prefixes ||= {}
+        return @@sized_prefixes[size] if @@sized_prefixes.key?(size)
 
-      def insert_vectors(dims)
-        dims.each do |key, value|
-          value[:vector] = vector(value)
-          value[:id] = key
-        end
+        @@sized_prefixes[size] = prefixes_array.select { |p| p.size == size }
       end
 
       def valid_path(file_name)

data/lib/unitsml/utility.rb

@@ -1,10 +1,14 @@
 # frozen_string_literal: true
 
-require "ox"
+require "unitsml/model/unit"
+require "unitsml/model/prefix"
+require "unitsml/model/quantity"
+require "unitsml/model/dimension"
+
 module Unitsml
   module Utility
+    Ox.default_options = { encoding: "UTF-8" }
 
-    UNITSML_NS = "https://schema.unitsml.org/unitsml/1.0".freeze
     # Unit to dimension
     U2D = {
       "m" => { dimension: "Length", order: 1, symbol: "L" },
@@ -43,10 +47,12 @@ module Unitsml
     ].freeze
 
     class << self
-      include Unitsml::Unitsdb
+      def unit_instance(unit)
+        Unitsdb.units.find_by_symbol_id(unit)
+      end
 
-      def fields(unit)
-        Unitsdb.units.dig(unit, :fields)
+      def quantity_instance(id)
+        Unitsdb.quantities.find_by_id(id)
       end
 
       def units2dimensions(units)
@@ -67,10 +73,9 @@ module Unitsml
       def dim_id(dims)
         return nil if dims.nil? || dims.empty?
 
-        dimensions = Unitsdb.dimensions_hash.values
         dim_hash = dims.each_with_object({}) { |h, m| m[h[:dimension]] = h }
         dims_vector = DIMS_VECTOR.map { |h| dim_hash.dig(h, :exponent) }.join(":")
-        id = dimensions.select { |d| d[:vector] == dims_vector }&.first&.dig(:id) and return id.to_s
+        id = Unitsdb.dimensions.find_by_vector(dims_vector)&.id and return id.to_s
         "D_" + dims.map do |d|
           (U2D.dig(d[:unit], :symbol) || Dim2D.dig(d[:id], :symbol)) +
             (d[:exponent] == 1 ? "" : float_to_display(d[:exponent]))
@@ -84,18 +89,18 @@ module Unitsml
       def decompose_unit(u)
         if u&.unit_name == "g" || u.system_type == "SI_base"
           { unit: u, prefix: u&.prefix }
-        elsif !u.si_derived_bases
+        elsif u.si_derived_bases.empty?
           { unit: Unit.new("unknown") }
         else
-          u.si_derived_bases.each_with_object([]) do |k, m|
-            prefix = if !k["prefix"].nil? && !k["prefix"].empty?
-                       combine_prefixes(prefix_object(k["prefix"]), u.prefix)
+          u.si_derived_bases.each_with_object([]) do |k, object|
+            prefix = if !k.prefix.nil? && !k.prefix.empty?
+                       combine_prefixes(prefix_object(k.prefix), u.prefix)
                      else
                        u.prefix
                      end
-            unit_name = Unitsdb.load_units.dig(k.dig("id"), "unit_symbols", 0, "id")
-            exponent = (k["power"]&.to_i || 1) * (u.power_numerator&.to_f || 1)
-            m << { prefix: prefix,
+            unit_name = Unitsdb.units.find_by_id(k.id).unit_symbols.first.id
+            exponent = (k.power&.to_i || 1) * (u.power_numerator&.to_f || 1)
+            object << { prefix: prefix,
                    unit: Unit.new(unit_name, exponent, prefix: prefix),
                  }
           end
@@ -118,9 +123,9 @@ module Unitsml
 
       def prefix_object(prefix)
         return prefix unless prefix.is_a?(String)
-        return nil unless Unitsdb.prefixes.any?(prefix)
+        return nil unless Unitsdb.prefixes_array.any?(prefix)
 
-        prefix.is_a?(String) ? Prefix.new(prefix) : prefix
+        Prefix.new(prefix)
       end
 
       def combine_prefixes(p1, p2)
@@ -129,7 +134,7 @@ module Unitsml
         return p2.symbolid if p1.nil?
         return "unknown" if p1.base != p2.base
 
-        Unitsdb.prefixes_hash.each do |prefix_name, _|
+        Unitsdb.prefixes_array.each do |prefix_name|
           p = prefix_object(prefix_name)
           return p if p.base == p1.base && p.power == p1.power + p2.power
         end
@@ -137,15 +142,16 @@ module Unitsml
         "unknown"
       end
 
-      def unit(units, formula, dims, norm_text, name)
-        attributes = { xmlns: UNITSML_NS, "xml:id": unit_id(norm_text) }
-        attributes[:dimensionURL] = "##{dim_id(dims)}" if dims
-        unit_node = ox_element("Unit", attributes: attributes)
-        nodes = Array(unitsystem(units))
-        nodes += Array(unitname(units, norm_text, name))
-        nodes += Array(unitsymbols(formula))
-        nodes += Array(rootunits(units))
-        Ox.dump(update_nodes(unit_node, nodes))
+      def unit(units, formula, dims, norm_text, name, options)
+        attributes = {
+          id: unit_id(norm_text),
+          system: unitsystem(units),
+          name: unitname(units, norm_text, name),
+          symbol: unitsymbols(formula, options),
+          root_units: rootunits(units),
+        }
+        attributes[:dimension_url] = "##{dim_id(dims)}" if dims
+        Model::Unit.new(attributes).to_xml
           .gsub("&lt;", "<")
           .gsub("&gt;", ">")
           .gsub("&amp;", "&")
@@ -154,8 +160,9 @@ module Unitsml
       end
 
       def unitname(units, text, name)
-        name ||= Unitsdb.units[text] ? Unit.new(text).enumerated_name : text
-        ox_element("UnitName", attributes: { "xml:lang": "en" }) << name
+        Model::Units::Name.new(
+          name: unit_instance(text)&.unit_name&.first || text
+        )
       end
 
       def postprocess_normtext(units)
@@ -166,47 +173,44 @@ module Unitsml
         unit.power_numerator && unit.power_numerator != "1" ? "^#{unit.power_numerator}" : ""
       end
 
-      def unitsymbols(formula)
-        [
-          (ox_element("UnitSymbol", attributes: { type: "HTML" }) << formula.to_html),
-          (ox_element("UnitSymbol", attributes: { type: "MathMl" }) << Ox.parse(formula.to_mathml)),
-        ]
+      def unitsymbols(formula, options)
+        %w[HTML MathMl].map do |lang|
+          Model::Units::Symbol.new(type: lang, content: formula.public_send(:"to_#{lang.downcase}", options))
+        end
       end
 
       def unitsystem(units)
         ret = []
         if units.any? { |u| u.system_name != "SI" }
-          ret << ox_element("UnitSystem", attributes: { name: "not_SI", type: "not_SI", "xml:lang": 'en-US' })
+          ret << Model::Units::System.new(name: "not_SI", type: "not_SI")
         end
         if units.any? { |u| u.system_name == "SI" }
           if units.size == 1
             base = units[0].system_type == "SI-base"
             base = true if units[0].unit_name == "g" && units[0]&.prefix_name == "k"
           end
-          ret << ox_element("UnitSystem", attributes: { name: "SI", type: (base ? 'SI_base' : 'SI_derived'), "xml:lang": 'en-US' })
+          ret << Model::Units::System.new(name: "SI", type: (base ? 'SI_base' : 'SI_derived'))
         end
         ret
       end
 
       def dimension(norm_text)
-        return unless fields(norm_text)&.dig("dimension_url")
-
-        dim_id = fields(norm_text).dig("dimension_url").sub("#", '')
-        dim_node = ox_element("Dimension", attributes: { xmlns: UNITSML_NS, "xml:id": dim_id })
-        Ox.dump(
-          update_nodes(
-            dim_node,
-            dimid2dimensions(dim_id)&.compact&.map { |u| dimension1(u) }
-          )
-        )
+        dim_url = unit_instance(norm_text)&.dimension_url
+        return unless dim_url
+
+        dim_id = dim_url.sub("#", '')
+        dim_attrs = { id: dim_id }
+        dimid2dimensions(dim_id)&.compact&.each { |u| dimension1(u, dim_attrs) }
+        Model::Dimension.new(dim_attrs).to_xml
       end
 
-      def dimension1(dim)
-        attributes = {
+      def dimension1(dim, dims_hash)
+        dim_name = dim[:dimension]
+        dim_klass = Model::DimensionQuantities.const_get(dim_name)
+        dims_hash[underscore(dim_name).to_sym] = dim_klass.new(
           symbol: dim[:symbol],
-          powerNumerator: float_to_display(dim[:exponent])
-        }
-        ox_element(dim[:dimension], attributes: attributes)
+          power_numerator: float_to_display(dim[:exponent])
+        )
       end
 
       def float_to_display(float)
@@ -214,97 +218,79 @@ module Unitsml
       end
 
       def dimid2dimensions(normtext)
-        dims ||= Unitsdb.load_dimensions[normtext]
-        dims&.keys&.reject { |d| d.is_a?(Symbol) }&.map do |k|
-          humanized = k.split("_").map(&:capitalize).join
+        dims = Unitsdb.dimensions.find_by_id(normtext)
+        dims&.processed_keys&.map do |processed_key|
+          humanized = processed_key.split("_").map(&:capitalize).join
           next unless DIMS_VECTOR.include?(humanized)
 
+          dim_quantity = dims.public_send(processed_key)
           {
             dimension: humanized,
-            symbol: dims.dig(k, "symbol"),
-            exponent: dims.dig(k, "powerNumerator")
+            symbol: dim_quantity.symbol,
+            exponent: dim_quantity.power_numerator,
           }
         end
       end
 
-      def prefixes(units)
+      def prefixes(units, options)
         uniq_prefixes = units.map { |unit| unit.prefix }.compact.uniq {|d| d.prefix_name }
-        uniq_prefixes.map do |p|
-          prefix_attr = { xmlns: UNITSML_NS, prefixBase: p&.base, prefixPower: p&.power, "xml:id": p&.id }
-          prefix_node = ox_element("Prefix", attributes: prefix_attr)
-          contents = []
-          contents << (ox_element("PrefixName", attributes: { "xml:lang": "en" }) << p&.name)
-          contents << (ox_element("PrefixSymbol", attributes: { type: "ASCII" }) << p&.to_asciimath)
-          contents << (ox_element("PrefixSymbol", attributes: { type: "unicode" }) << p&.to_unicode)
-          contents << (ox_element("PrefixSymbol", attributes: { type: "LaTex" }) << p&.to_latex)
-          contents << (ox_element("PrefixSymbol", attributes: { type: "HTML" }) << p&.to_html)
-          Ox.dump(update_nodes(prefix_node, contents)).gsub("&amp;", "&")
+        uniq_prefixes.map do |prefix|
+          prefix_attrs = { prefix_base: prefix&.base, prefix_power: prefix&.power, id: prefix&.id }
+          type_and_methods = { ASCII: :to_asciimath, unicode: :to_unicode, LaTex: :to_latex, HTML: :to_html }
+          prefix_attrs[:name] = Model::Prefixes::Name.new(content: prefix&.name)
+          prefix_attrs[:symbol] = type_and_methods.map do |type, method_name|
+            Model::Prefixes::Symbol.new(
+              type: type,
+              content: prefix&.public_send(method_name, options),
+            )
+          end
+          Model::Prefix.new(prefix_attrs).to_xml.gsub("&amp;", "&")
         end.join("\n")
       end
 
       def rootunits(units)
         return if units.size == 1 && !units[0].prefix
 
-        root_unit = ox_element("RootUnits")
-        units.each do |u|
-          attributes = { unit: u.enumerated_name }
-          attributes[:prefix] = u.prefix_name if u.prefix
-          u.power_numerator && u.power_numerator != "1" and
-            attributes[:powerNumerator] = u.power_numerator
-          root_unit << ox_element("EnumeratedRootUnit", attributes: attributes)
+        enum_root_units = units.map do |unit|
+          attributes = { unit: unit.enumerated_name }
+          attributes[:prefix] = unit.prefix_name if unit.prefix
+          unit.power_numerator && unit.power_numerator != "1" and
+            attributes[:power_numerator] = unit.power_numerator
+          Model::Units::EnumeratedRootUnit.new(attributes)
         end
-        root_unit
+        Model::Units::RootUnits.new(enumerated_root_unit: enum_root_units)
       end
 
       def unit_id(text)
         norm_text = text
         text = text&.gsub(/[()]/, "")
-        /-$/.match(text) and return Unitsdb.prefixes[text.sub(/-$/, "")][:id]
-        unit_hash = Unitsdb.units[norm_text]
-        "U_#{unit_hash ? unit_hash[:id]&.gsub(/'/, '_') : norm_text&.gsub(/\*/, '.')&.gsub(/\^/, '')}"
+        unit = unit_instance(norm_text)
+        "U_#{unit ? unit.id&.gsub(/'/, '_') : norm_text&.gsub(/\*/, '.')&.gsub(/\^/, '')}"
       end
 
       def dimension_components(dims)
         return if dims.nil? || dims.empty?
 
-        attributes = { xmlns: UNITSML_NS, "xml:id": dim_id(dims) }
-        dim_node = ox_element("Dimension", attributes: attributes)
-        Ox.dump(update_nodes(dim_node, dims.map { |u| dimension1(u) }))
+        dim_attrs = { id: dim_id(dims) }
+        dims.map { |u| dimension1(u, dim_attrs) }
+        Model::Dimension.new(dim_attrs).to_xml
       end
 
       def quantity(normtext, quantity)
-        units = Unitsdb.units
-        quantity_references = units.dig(normtext, :fields, "quantity_reference")
-        return unless units[normtext] && quantity_references.size == 1 ||
-          Unitsdb.quantities[quantity]
-
-        id = quantity || quantity_references&.first&.dig("url")
-        attributes = { xmlns: UNITSML_NS, "xml:id": id.sub('#', '') }
-        dim_url = units.dig(normtext, :fields, "dimension_url")
-        dim_url and attributes[:dimensionURL] = "#{dim_url}"
-        attributes[:quantityType] = "base"
-        quantity_element = ox_element("Quantity", attributes: attributes)
-        Ox.dump(update_nodes(quantity_element, quantity_name(id.sub('#', ''))))
+        unit = unit_instance(normtext)
+        return unless unit && unit.quantity_reference.size == 1 ||
+          quantity_instance(quantity)
+
+        id = (quantity || unit.quantity_reference&.first&.url).sub('#', '')
+        dim_url = unit.dimension_url
+        attributes = { id: id, name: quantity_name(id), dimension_url: dim_url }
+        Model::Quantity.new(attributes).to_xml
       end
 
       def quantity_name(id)
-        ret = []
-        Unitsdb.quantities[id]&.dig("quantity_name")&.each do |q|
-          node = (ox_element("QuantityName", attributes: { "xml:lang": "en-US" }) << q)
-          ret << node
+        quantity_instance(id)&.quantity_name&.map do |content|
+          Model::Quantities::Name.new(content: content)
         end
-        ret
-      end
-
-      def ox_element(node, attributes: [])
-        element = Ox::Element.new(node)
-        attributes&.each { |attr_key, attr_value| element[attr_key] = attr_value }
-        element
-      end
-
-      def update_nodes(element, nodes)
-        nodes&.each { |node| element << node unless node.nil? }
-        element
       end
 
       def string_to_html_entity(string)
@@ -319,6 +305,14 @@ module Unitsml
         entities = HTMLEntities.new
         entities.decode(string)
       end
+
+      def underscore(str)
+        str.gsub(/([a-z])([A-Z])/, '\1_\2').downcase
+      end
+
+      def class_name(klass)
+        klass.name.split("::").last
+      end
     end
   end
 end

data/lib/unitsml/version.rb

@@ -1,3 +1,3 @@
 module Unitsml
-  VERSION = "0.2.9"
+  VERSION = "0.4.0"
 end

data/lib/unitsml.rb

@@ -1,3 +1,14 @@
+# frozen_string_literal: true
+
+module Unitsml
+  UNITSML_NS = "https://schema.unitsml.org/unitsml/1.0".freeze
+
+  def self.parse(string)
+    Unitsml::Parser.new(string).parse
+  end
+end
+
+require "unitsml/error"
 require "unitsml/sqrt"
 require "unitsml/unit"
 require "unitsml/parse"
@@ -9,9 +20,19 @@ require "unitsml/unitsdb"
 require "unitsml/extender"
 require "unitsml/dimension"
 require "unitsml/transform"
-
-module Unitsml
-  def self.parse(string)
-    Unitsml::Parser.new(string).parse
-  end
-end
+require "unitsml/unitsdb/units"
+require "unitsml/unitsdb/prefixes"
+require "unitsml/unitsdb/dimension"
+require "unitsml/unitsdb/dimensions"
+require "unitsml/unitsdb/quantities"
+require "unitsml/unitsdb/dimension_quantity"
+require "unitsdb/config"
+Unitsdb::Config.models = {
+  units: Unitsml::Unitsdb::Units,
+  prefixes: Unitsml::Unitsdb::Prefixes,
+  dimension: Unitsml::Unitsdb::Dimension,
+  dimensions: Unitsml::Unitsdb::Dimensions,
+  quantities: Unitsml::Unitsdb::Quantities,
+  dimension_quantity: Unitsml::Unitsdb::DimensionQuantity,
+}
+require "unitsdb"

data/unitsml.gemspec

@@ -28,12 +28,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib", "unitsdb/**/*.yaml"]
 
   spec.add_dependency "htmlentities"
-  spec.add_dependency "plurimath", "~> 0.8.4"
-  spec.add_development_dependency "byebug"
-  spec.add_development_dependency "equivalent-xml"
-  spec.add_development_dependency "pry", "~> 0.12.2"
-  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_dependency "mml"
+  spec.add_dependency "parslet"
+  spec.add_dependency "unitsdb"
 end