plurimath 0.4.1 → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0ae20aeedcb99f6b913e591de0bf18624aae42c750df4ea706d90a6c47be4193
-  data.tar.gz: d1e9513bd715e585b57fffc72f1c0a6e163b6ac7ea4d270fe2e8323301f89036
+  metadata.gz: 0ec251305cefca33f4a6d66180a797595d43ef370d55f7b67bdeac63b37e3111
+  data.tar.gz: 2c041edf5748e938813a20e0d397080d2f8cedcf96b19e9e39e98edae6b47ef8
 SHA512:
-  metadata.gz: 6532186819c4523f46d6dc3503df5b88972f5c68cb54a3bd3e7ff66a1d8bd6d8b4346eac33a0ef2504bfcb4a1f813eb7130e9bb55b8196e3b2878b0733c7dad0
-  data.tar.gz: c9cbda12a71c9e0e57c04a92737945eef6ff79a6cbc35c3e0bdc7b0eddc0443af0e8614bd5d803db64de7e036b385324fe5f0c91a5faa3c601886d63eade5325
+  metadata.gz: 37065161c1a09768bbec28f0d98e5438be18a5a0affa9e6024f7027ad002324c1e66e63c22f921f43fd32fa2bf1b723ace3f08b99464a8af3b7e6d265e092df6
+  data.tar.gz: 596e9cb2ce7f7d41ab8f93b4c0f330ffcdfec6adba518b49086dc4792c12f7eafed799ee087ea2ea82a3753389c179fab8883445c1b804a52fe779314941280c

data/lib/plurimath/latex/constants.rb

@@ -2853,6 +2853,7 @@ module Plurimath
         mathbfit: :fonts,
         mathfrak: :fonts,
         overline: :unary,
+        overset: :binary,
         ddagger: :symbols,
         trprime: :symbols,
         closure: :symbols,

data/lib/plurimath/latex/parse.rb

@@ -95,11 +95,18 @@ module Plurimath
       end
 
       rule(:intermediate_exp) do
-        (lparen.as(:left_paren) >> expression.maybe.as(:expression) >> rparen.as(:right_paren)).as(:intermediate_exp) |
+        (lparen.as(:left_paren) >> expression.maybe.as(:expression) >> (rparen | (str("\\") >> (match("\s") >> str(".")).maybe).as(:rparen)).maybe.as(:right_paren)).as(:intermediate_exp) |
           (str("{") >> expression.maybe.as(:expression) >> str("}")) |
           symbol_text_or_integer
       end
 
+      rule(:parsing_text_values) do
+        (str("{") >> parsing_text_values >> str("}")) >> parsing_text_values |
+          (str("{") >> parsing_text_values >> str("}")) |
+          (match("[^}]") >> parsing_text_values) |
+          match("[^}]").repeat
+      end
+
       rule(:power_base) do
         (subscript >> power >> intermediate_exp.as(:supscript)).as(:power_base) |
           (supscript >> base >> intermediate_exp.as(:subscript)).as(:power_base) |
@@ -130,7 +137,8 @@ module Plurimath
           (begining >> expression.as(:table_data) >> ending).as(:environment) |
           (slash >> environment >> intermediate_exp).as(:table_data) |
           power_base |
-          intermediate_exp
+          intermediate_exp |
+          intermediate_exp.as(:intermediate_exp) >> rparen.as(:symbol)
       end
 
       rule(:left_right) do
@@ -204,7 +212,7 @@ module Plurimath
         when :binary
           (slashed_value(first_value, :binary) >> intermediate_exp.as(:first_value) >> intermediate_exp.as(:second_value)).as(:binary)
         when :text
-          (slashed_value(first_value, :text) >> (str("{") >> match("[^}]").repeat.as(:first_value) >> str("}")))
+          (slashed_value(first_value, :text) >> (str("{") >> parsing_text_values.as(:first_value) >> str("}")))
         when :ternary
           (slashed_value(first_value, :ternary_functions) >> dynamic_power_base >> sequence.as(:third_value).maybe).as(:ternary_class) |
             slashed_value(first_value, :ternary)

data/lib/plurimath/latex/transform.rb

@@ -45,13 +45,9 @@ module Plurimath
       end
 
       rule(symbols: simple(:sym)) do
-        if sym.is_a?(Parslet::Slice)
-          Math::Symbol.new(
-            Constants::UNICODE_SYMBOLS[sym.to_sym] || sym,
-          )
-        else
-          sym
-        end
+        Math::Symbol.new(
+          Constants::UNICODE_SYMBOLS[sym.to_sym] || sym,
+        )
       end
 
       rule(lparen: simple(:lparen),
@@ -404,6 +400,16 @@ module Plurimath
         )
       end
 
+      rule(number: simple(:number),
+           subscript: simple(:subscript),
+           supscript: simple(:supscript)) do
+        Math::Function::PowerBase.new(
+          Math::Number.new(number),
+          subscript,
+          supscript,
+        )
+      end
+
       rule(symbols: simple(:sym),
            subscript: simple(:subscript)) do
         Math::Function::Base.new(
@@ -469,6 +475,47 @@ module Plurimath
         Math::Function::Text.new(first_value)
       end
 
+      rule(text: simple(:text),
+           first_value: sequence(:first_value)) do
+        Math::Function::Text.new(first_value.join)
+      end
+
+      rule(text: simple(:text),
+           first_value: simple(:first_value),
+           supscript: simple(:supscript),) do
+        Math::Function::Power.new(
+          Math::Function::Text.new(first_value),
+          supscript,
+        )
+      end
+
+      rule(text: simple(:text),
+           first_value: sequence(:first_value),
+           supscript: simple(:supscript),) do
+        Math::Function::Power.new(
+          Math::Function::Text.new(first_value.join),
+          supscript,
+        )
+      end
+
+      rule(text: simple(:text),
+           first_value: sequence(:first_value),
+           subscript: simple(:subscript),) do
+        Math::Function::Base.new(
+          Math::Function::Text.new(first_value.join),
+          subscript,
+        )
+      end
+
+      rule(text: simple(:text),
+           first_value: simple(:first_value),
+           subscript: simple(:subscript),) do
+        Math::Function::Base.new(
+          Math::Function::Text.new(first_value),
+          subscript,
+        )
+      end
+
       rule(unary: simple(:unary),
            first_value: simple(:first_value)) do
         Utility.get_class(
@@ -521,6 +568,28 @@ module Plurimath
         )
       end
 
+      rule(fonts: simple(:fonts),
+           intermediate_exp: simple(:int_exp),
+           subscript: simple(:subscript),
+           supscript: simple(:supscript)) do
+        font_style = if Utility::FONT_STYLES[fonts.to_sym].nil?
+                       Math::Function::FontStyle.new(
+                         int_exp,
+                         fonts.to_s,
+                       )
+                     else
+                       Utility::FONT_STYLES[fonts.to_sym].new(
+                         int_exp,
+                         fonts.to_s,
+                       )
+                     end
+        Math::Function::PowerBase.new(
+          font_style,
+          subscript,
+          supscript,
+        )
+      end
+
       rule(root: simple(:root),
            first_value: simple(:first_value),
            second_value: simple(:second_value)) do
@@ -626,6 +695,23 @@ module Plurimath
         )
       end
 
+      rule(binary: simple(:binary),
+           subscript: simple(:subscript),
+           supscript: simple(:supscript)) do
+        if binary.is_a?(Parslet::Slice)
+          Utility.get_class(binary).new(
+            subscript,
+            supscript,
+          )
+        else
+          Math::Function::PowerBase.new(
+            binary,
+            subscript,
+            subscript,
+          )
+        end
+      end
+
       rule(binary: simple(:binary),
            subscript: simple(:subscript)) do
         if binary.is_a?(Parslet::Slice)

data/lib/plurimath/math/function/bar.rb

@@ -1,11 +1,18 @@
 # frozen_string_literal: true
 
-require_relative "binary_function"
+require_relative "unary_function"
 
 module Plurimath
   module Math
     module Function
-      class Bar < BinaryFunction
+      class Bar < UnaryFunction
+        attr_accessor :attributes
+
+        def initialize(parameter_one = nil, attributes = {})
+          super(parameter_one)
+          @attributes = attributes
+        end
+
         def to_asciimath
           first_value = "(#{parameter_one.to_asciimath})" if parameter_one
           "bar#{first_value}"
@@ -21,7 +28,7 @@ module Plurimath
           return mo_tag unless parameter_one
 
           mover_tag = Utility.ox_element("mover")
-          mover_tag.attributes.merge!(parameter_two) if parameter_two && !parameter_two.empty?
+          mover_tag.attributes.merge!(attributes) if attributes && !attributes.empty?
           Utility.update_nodes(
             mover_tag,
             [
@@ -32,13 +39,13 @@ module Plurimath
         end
 
         def to_omml_without_math_tag(display_style)
-          return r_element("&#xaf;", rpr_tag: false) unless all_values_exist?
+          return r_element("&#xaf;", rpr_tag: false) unless parameter_one
 
-          parameter_two && parameter_two[:accent] ? acc_tag(display_style) : bar_tag(display_style)
+          attributes && attributes[:accent] ? acc_tag(display_style) : bar_tag(display_style)
         end
 
         def swap_class
-          Ul.new(parameter_one, parameter_two)
+          Ul.new(parameter_one, attributes)
         end
 
         protected

data/lib/plurimath/math/function/binary_function.rb

@@ -56,6 +56,10 @@ module Plurimath
           [r_tag]
         end
 
+        def any_value_exist?
+          !(parameter_one.nil? || parameter_two.nil?)
+        end
+
         def all_values_exist?
           !(parameter_one.nil? && parameter_two.nil?)
         end

data/lib/plurimath/math/function/ddot.rb

@@ -6,6 +6,13 @@ module Plurimath
   module Math
     module Function
       class Ddot < UnaryFunction
+        attr_accessor :attributes
+
+        def initialize(parameter_one = nil, attributes = {})
+          super(parameter_one)
+          @attributes = attributes
+        end
+
         def to_mathml_without_math_tag
           second_value = Utility.ox_element("mo") << ".."
           Utility.update_nodes(

data/lib/plurimath/math/function/dot.rb

@@ -1,19 +1,26 @@
 # frozen_string_literal: true
 
-require_relative "binary_function"
+require_relative "unary_function"
 
 module Plurimath
   module Math
     module Function
-      class Dot < BinaryFunction
+      class Dot < UnaryFunction
+        attr_accessor :attributes
+
+        def initialize(parameter_one = nil, attributes = {})
+          super(parameter_one)
+          @attributes = attributes
+        end
+
         def to_mathml_without_math_tag
           dot_tag = (Utility.ox_element("mo") << ".")
-          return dot_tag unless all_values_exist?
+          return dot_tag unless parameter_one
 
           first_value = parameter_one&.to_mathml_without_math_tag
           dot_tag = (Utility.ox_element("mo") << ".")
           over_tag = Utility.ox_element("mover")
-          over_tag.attributes.merge!({ accent: parameter_two[:accent] }) if parameter_two
+          over_tag.attributes.merge!({ accent: attributes[:accent] }) if attributes && attributes[:accent]
           Utility.update_nodes(
             over_tag,
             [
@@ -24,9 +31,9 @@ module Plurimath
         end
 
         def to_omml_without_math_tag(display_style)
-          return r_element(".", rpr_tag: false) unless all_values_exist?
+          return r_element(".", rpr_tag: false) unless parameter_one
 
-          if parameter_two && parameter_two[:accent]
+          if attributes && attributes[:accent]
             acc_tag(display_style)
           else
             symbol = Symbol.new(".")

data/lib/plurimath/math/function/fenced.rb

@@ -30,11 +30,9 @@ module Plurimath
         end
 
         def to_latex
-          open_paren   = parameter_one ? parameter_one.value : "("
           fenced_value = parameter_two&.map(&:to_latex)&.join(" ")
-          close_paren  = parameter_three ? parameter_three.value : ")"
-          first_value  = latex_paren(open_paren)
-          second_value = latex_paren(close_paren)
+          first_value  = latex_paren(parameter_one&.value)
+          second_value = latex_paren(parameter_three&.value)
           "#{first_value} #{fenced_value} #{second_value}"
         end
 
@@ -88,8 +86,8 @@ module Plurimath
           return "" if paren.nil? || paren.empty?
 
           paren = %w[{ }].include?(paren) ? "\\#{paren}" : paren
-          paren = "\\#{Latex::Constants::UNICODE_SYMBOLS.invert[paren]}" if paren.to_s.match?(/&#x.{0,4};/)
-          paren.to_s
+          paren = "\\#{Latex::Constants::UNICODE_SYMBOLS.invert[paren]}" if paren&.to_s&.match?(/&#x.{0,4};/)
+          paren&.to_s
         end
 
         def mathml_paren(field)

data/lib/plurimath/math/function/font_style.rb

@@ -21,6 +21,10 @@ module Plurimath
           )
         end
 
+        def to_omml_without_math_tag(display_style)
+          font_styles(display_style)
+        end
+
         def to_html
           parameter_one&.to_html
         end

data/lib/plurimath/math/function/hat.rb

@@ -1,11 +1,18 @@
 # frozen_string_literal: true
 
-require_relative "binary_function"
+require_relative "unary_function"
 
 module Plurimath
   module Math
     module Function
-      class Hat < BinaryFunction
+      class Hat < UnaryFunction
+        attr_accessor :attributes
+
+        def initialize(parameter_one = nil, attributes = {})
+          super(parameter_one)
+          @attributes = attributes
+        end
+
         def to_asciimath
           first_value = "(#{parameter_one.to_asciimath})" if parameter_one
           "hat#{first_value}"
@@ -21,7 +28,7 @@ module Plurimath
           return mo_tag unless parameter_one
 
           mover_tag = Utility.ox_element("mover")
-          mover_tag.attributes.merge!(parameter_two) if parameter_two && !parameter_two.empty?
+          mover_tag.attributes.merge!(attributes) if attributes && !attributes.empty?
           Utility.update_nodes(
             mover_tag,
             [
@@ -36,9 +43,9 @@ module Plurimath
         end
 
         def to_omml_without_math_tag(display_style)
-          return r_element("^", rpr_tag: false) unless all_values_exist?
+          return r_element("^", rpr_tag: false)  unless parameter_one
 
-          if parameter_two && parameter_two[:accent]
+          if attributes && attributes[:accent]
             accent_tag(display_style)
           else
             symbol = Symbol.new("&#x302;")

data/lib/plurimath/math/function/obrace.rb

@@ -1,11 +1,18 @@
 # frozen_string_literal: true
 
-require_relative "binary_function"
+require_relative "unary_function"
 
 module Plurimath
   module Math
     module Function
-      class Obrace < BinaryFunction
+      class Obrace < UnaryFunction
+        attr_accessor :attributes
+
+        def initialize(parameter_one = nil, attributes = {})
+          super(parameter_one)
+          @attributes = attributes
+        end
+
         def to_asciimath
           first_value = "(#{parameter_one.to_asciimath})" if parameter_one
           "obrace#{first_value}"
@@ -21,7 +28,7 @@ module Plurimath
           return mo_tag unless parameter_one
 
           over_tag = Utility.ox_element("mover")
-          over_tag.attributes.merge!(parameter_two) if parameter_two && !parameter_two.empty?
+          over_tag.attributes.merge!(attributes) if attributes && !attributes.empty?
           Utility.update_nodes(
             over_tag,
             [
@@ -36,9 +43,9 @@ module Plurimath
         end
 
         def to_omml_without_math_tag(display_style)
-          return r_element("⏞", rpr_tag: false) unless all_values_exist?
+          return r_element("⏞", rpr_tag: false) unless parameter_one
 
-          if parameter_two && parameter_two[:accent]
+          if attributes && attributes[:accent]
             acc_tag(display_style)
           else
             symbol = Symbol.new("⏞")

data/lib/plurimath/math/function/ternary_function.rb

@@ -55,6 +55,10 @@ module Plurimath
           !(parameter_one.nil? || parameter_two.nil? || parameter_three.nil?)
         end
 
+        def all_values_exist?
+          !(parameter_one.nil? && parameter_two.nil? && parameter_three.nil?)
+        end
+
         protected
 
         def latex_wrapped(field)
@@ -108,8 +112,8 @@ module Plurimath
         def narypr(function_symbol, function_type: "undOvr")
           chr_arg     = { "m:val": function_symbol }
           limloc_arg  = { "m:val": function_type }
-          subhide_arg = { "m:val": "0" }
-          suphide_arg = { "m:val": "0" }
+          subhide_arg = { "m:val": parameter_one ? "0" : "1" }
+          suphide_arg = { "m:val": parameter_two ? "0" : "1" }
           chr_tag     = Utility.ox_element("chr", attributes: chr_arg, namespace: "m")
           limloc_tag  = Utility.ox_element("limLoc", attributes: limloc_arg, namespace: "m")
           subhide_tag = Utility.ox_element("subHide", attributes: subhide_arg, namespace: "m")
@@ -126,10 +130,6 @@ module Plurimath
           )
         end
 
-        def all_values_exist?
-          !(parameter_one.nil? && parameter_two.nil? && parameter_three.nil?)
-        end
-
         def validate_mathml_tag(parameter)
           return Array(Utility.ox_element("mrow")) unless parameter
 

data/lib/plurimath/math/function/text.rb

@@ -68,7 +68,7 @@ module Plurimath
           if lang == "omml"
             entities = HTMLEntities.new
             entities.encode(
-              entities.decode(parameter_one.gsub(/ /, " ")),
+              entities.decode(parameter_one&.gsub(/ /, " ")),
               :named,
             )
           else

data/lib/plurimath/math/function/tilde.rb

@@ -1,23 +1,30 @@
 # frozen_string_literal: true
 
-require_relative "binary_function"
+require_relative "unary_function"
 
 module Plurimath
   module Math
     module Function
-      class Tilde < BinaryFunction
+      class Tilde < UnaryFunction
+        attr_accessor :attributes
+
+        def initialize(parameter_one = nil, attributes = {})
+          super(parameter_one)
+          @attributes = attributes
+        end
+
         def to_mathml_without_math_tag
           mover = Utility.ox_element("mover")
-          mover.attributes.merge!({ accent: parameter_two[:accent]}) if parameter_two
+          mover.attributes.merge!({ accent: attributes[:accent]}) if attributes && attributes[:accent]
           first_value = (Utility.ox_element("mo") << "~")
           second_value = parameter_one.to_mathml_without_math_tag if parameter_one
           Utility.update_nodes(mover, [second_value, first_value])
         end
 
         def to_omml_without_math_tag(display_style)
-          return r_element("~", rpr_tag: false) unless all_values_exist?
+          return r_element("~", rpr_tag: false) unless parameter_one
 
-          if parameter_two && parameter_two[:accent]
+          if attributes && attributes[:accent]
             acc_tag(display_style)
           else
             symbol = Symbol.new("~")

data/lib/plurimath/math/function/ubrace.rb

@@ -1,11 +1,18 @@
 # frozen_string_literal: true
 
-require_relative "binary_function"
+require_relative "unary_function"
 
 module Plurimath
   module Math
     module Function
-      class Ubrace < BinaryFunction
+      class Ubrace < UnaryFunction
+        attr_accessor :attributes
+
+        def initialize(parameter_one = nil, attributes = {})
+          super(parameter_one)
+          @attributes = attributes
+        end
+
         def to_asciimath
           first_value = "(#{parameter_one.to_asciimath})" if parameter_one
           "ubrace#{first_value}"
@@ -21,7 +28,7 @@ module Plurimath
           return mo_tag unless parameter_one
 
           over_tag = Utility.ox_element("munder")
-          over_tag.attributes.merge!(parameter_two) if parameter_two && !parameter_two.empty?
+          over_tag.attributes.merge!(attributes) if attributes && !attributes.empty?
           Utility.update_nodes(
             over_tag,
             [
@@ -44,7 +51,7 @@ module Plurimath
         end
 
         def to_omml_without_math_tag(display_style)
-          return r_element("⏟", rpr_tag: false) unless all_values_exist?
+          return r_element("⏟", rpr_tag: false) unless parameter_one
 
           symbol = Symbol.new("⏟")
           Underset.new(parameter_one, symbol).to_omml_without_math_tag(true)

data/lib/plurimath/math/function/ul.rb

@@ -1,11 +1,18 @@
 # frozen_string_literal: true
 
-require_relative "binary_function"
+require_relative "unary_function"
 
 module Plurimath
   module Math
     module Function
-      class Ul < BinaryFunction
+      class Ul < UnaryFunction
+        attr_accessor :attributes
+
+        def initialize(parameter_one = nil, attributes = {})
+          super(parameter_one)
+          @attributes = attributes
+        end
+
         def to_asciimath
           first_value = "(#{parameter_one.to_asciimath})" if parameter_one
           "underline#{first_value}"
@@ -21,7 +28,7 @@ module Plurimath
           return mo_tag unless parameter_one
 
           munder_tag = Utility.ox_element("munder")
-          munder_tag.attributes.merge!(parameter_two) if parameter_two && !parameter_two.empty?
+          munder_tag.attributes.merge!(attributes) if attributes && !attributes.empty?
           Utility.update_nodes(
             munder_tag,
             [
@@ -32,9 +39,9 @@ module Plurimath
         end
 
         def to_omml_without_math_tag(display_style)
-          return r_element("&#x332;", rpr_tag: false) unless all_values_exist?
+          return r_element("&#x332;", rpr_tag: false) unless parameter_one
 
-          if parameter_two && parameter_two[:accentunder]
+          if attributes && attributes[:accentunder]
             groupchr_tag(display_style)
           else
             symbol = Symbol.new("&#x332;")
@@ -47,7 +54,7 @@ module Plurimath
         end
 
         def swap_class
-          Bar.new(parameter_one, parameter_two)
+          Bar.new(parameter_one, attributes)
         end
 
         protected

data/lib/plurimath/math/function/unary_function.rb

@@ -39,8 +39,7 @@ module Plurimath
         end
 
         def to_latex
-          first_value = "{#{latex_value}}" if parameter_one
-          "\\#{class_name}#{first_value}"
+          "\\#{class_name}{#{latex_value}}"
         end
 
         def to_html
@@ -49,7 +48,7 @@ module Plurimath
                         elsif parameter_one
                           "<i>#{parameter_one.to_html}</i>"
                         end
-          "<i>#{class_name}</i>#{first_value}"
+        "<i>#{invert_unicode_symbols}</i>#{first_value}"
         end
 
         def to_omml_without_math_tag(display_style)
@@ -78,6 +77,10 @@ module Plurimath
 
         protected
 
+        def invert_unicode_symbols
+          Mathml::Constants::UNICODE_SYMBOLS.invert[class_name] || class_name
+        end
+
         def asciimath_value
           return "" unless parameter_one
 

data/lib/plurimath/math/function/vec.rb

@@ -1,15 +1,22 @@
 # frozen_string_literal: true
 
-require_relative "binary_function"
+require_relative "unary_function"
 
 module Plurimath
   module Math
     module Function
-      class Vec < BinaryFunction
+      class Vec < UnaryFunction
+        attr_accessor :attributes
+
+        def initialize(parameter_one = nil, attributes = {})
+          super(parameter_one)
+          @attributes = attributes
+        end
+
         def to_mathml_without_math_tag
           mover = Utility.ox_element("mover")
           first_value = parameter_one&.to_mathml_without_math_tag
-          mover.attributes.merge!({ accent: parameter_two[:accent] }) if parameter_two
+          mover.attributes.merge!({ accent: attributes[:accent] }) if attributes && attributes[:accent]
           Utility.update_nodes(
             mover,
             [
@@ -20,9 +27,9 @@ module Plurimath
         end
 
         def to_omml_without_math_tag(display_style)
-          return r_element("&#x2192;", rpr_tag: false) unless all_values_exist?
+          return r_element("&#x2192;", rpr_tag: false) unless parameter_one
 
-          if parameter_two && parameter_two[:accent]
+          if attributes && attributes[:accent]
             acc_tag(display_style)
           else
             symbol = Symbol.new("→")

data/lib/plurimath/mathml/parser.rb

@@ -7,7 +7,7 @@ module Plurimath
     class Parser
       attr_accessor :text
 
-      SUPPORTED_ATTRIBUTES = %w[
+      SUPPORTED_ATTRS = %w[
         columnlines
         mathvariant
         accentunder
@@ -24,11 +24,11 @@ module Plurimath
 
       def parse
         ox_nodes = Ox.load(text, strip_namespace: true)
-        display_style = ox_nodes&.locate("*/mstyle/@displaystyle")&.first || true
+        display_style = ox_nodes&.locate("*/mstyle/@displaystyle")&.first
         nodes = parse_nodes(ox_nodes.nodes)
         Math::Formula.new(
           Transform.new.apply(nodes).flatten.compact,
-          display_style: display_style,
+          display_style: (display_style || true),
         )
       end
 
@@ -39,12 +39,7 @@ module Plurimath
           if node.is_a?(String)
             node
           elsif !node.attributes.empty?
-            {
-              node.name.to_sym => {
-                attributes: validate_attributes(node.attributes),
-                value: parse_nodes(node.nodes),
-              },
-            }
+            attrs_hash(node)
           else
             { node.name.to_sym => parse_nodes(node.nodes) }
           end
@@ -52,9 +47,18 @@ module Plurimath
       end
 
       def validate_attributes(attributes)
-        attributes&.select! { |key, _| SUPPORTED_ATTRIBUTES.include?(key&.to_s) }
+        attributes&.select! { |key, _| SUPPORTED_ATTRS.include?(key&.to_s) }
         attributes&.transform_keys(&:to_sym) if attributes&.any?
       end
+
+      def attrs_hash(node)
+        {
+          node.name.to_sym => {
+            attributes: validate_attributes(node.attributes),
+            value: parse_nodes(node.nodes),
+          },
+        }
+      end
     end
   end
 end

data/lib/plurimath/mathml/transform.rb

@@ -136,16 +136,17 @@ module Plurimath
       end
 
       rule(msubsup: sequence(:function)) do
-        base_class = function[0].is_a?(Math::Formula) ? function[0]&.value&.first : function[0]
-        if base_class.is_a?(Math::Function::BinaryFunction)
-          base_class.parameter_one = function[1]
-          base_class.parameter_two = function[2]
-          base_class
-        elsif base_class.is_a?(Math::Function::TernaryFunction)
-          base_class.parameter_one = function[1]
-          base_class.parameter_two = function[2]
-          base_class.parameter_three = function[3]
-          base_class
+        base = function[0].is_a?(Math::Formula) ? function[0].value : function
+        base_object = base.first
+        if base_object.is_a?(Math::Function::BinaryFunction) && !base_object.any_value_exist?
+          base_object.parameter_one = function[1]
+          base_object.parameter_two = function[2]
+          base_object
+        elsif base_object.is_a?(Math::Function::TernaryFunction) && !base_object.any_value_exist?
+          base_object.parameter_one = function[1]
+          base_object.parameter_two = function[2]
+          base_object.parameter_three = function[3]
+          base_object
         else
           Math::Function::PowerBase.new(
             function[0],
@@ -156,16 +157,17 @@ module Plurimath
       end
 
       rule(munderover: sequence(:function)) do
-        base_class = function[0].is_a?(Math::Formula) ? function[0]&.value&.first : function[0]
-        if base_class.is_a?(Math::Function::BinaryFunction)
-          base_class.parameter_one = function[1]
-          base_class.parameter_two = function[2]
-          base_class
-        elsif base_class.is_a?(Math::Function::TernaryFunction)
-          base_class.parameter_one = function[1]
-          base_class.parameter_two = function[2]
-          base_class.parameter_three = function[3]
-          base_class
+        base = function[0].is_a?(Math::Formula) ? function[0].value : function
+        base_object = base.first
+        if base_object.is_a?(Math::Function::BinaryFunction) && !base_object.any_value_exist?
+          base_object.parameter_one = function[1]
+          base_object.parameter_two = function[2]
+          base_object
+        elsif base_object.is_a?(Math::Function::TernaryFunction) && !base_object.any_value_exist?
+          base_object.parameter_one = function[1]
+          base_object.parameter_two = function[2]
+          base_object.parameter_three = function[3]
+          base_object
         else
           Math::Function::Underover.new(
             function[0],
@@ -177,6 +179,7 @@ module Plurimath
 
       rule(mrow: subtree(:mrow)) do
         flatten_mrow = Utility.populate_function_classes(mrow)
+        Utility.fenceable_classes(flatten_mrow)
         if flatten_mrow.length == 1
           flatten_mrow.first
         else
@@ -198,13 +201,9 @@ module Plurimath
       end
 
       rule(mover: subtree(:mover)) do
-        Utility.binary_function_classes(mover, under: true)
         if mover&.length == 1
-          if mover.first.class_name == "underline"
-            mover.first.swap_class
-          else
-            mover.first
-          end
+          base_object = mover.first
+          base_object.class_name == "underline" ? base_object.swap_class : base_object
         elsif Constants::CLASSES.any?(mover&.last&.class_name)
           mover.last.parameter_one = mover.shift if mover.length > 1
           mover.last
@@ -219,19 +218,16 @@ module Plurimath
       rule(munder: sequence(:munder)) do
         if munder.any?(String)
           munder.each_with_index do |object, ind|
-            munder[ind] = Utility.mathml_unary_classes([object]) if object.is_a?(String)
+            next unless object.is_a?(String)
+
+            munder[ind] = Utility.mathml_unary_classes([object])
           end
         end
-        Utility.binary_function_classes(munder, under: true)
-        if ["ubrace", "obrace"].any?(munder.last.class_name)
+        if munder.length == 1
+          munder.first.class_name == "bar" ? munder.first.swap_class : munder.last
+        elsif ["ubrace", "obrace", "underline"].any?(munder.last.class_name)
           munder.last.parameter_one = munder.shift if munder.length > 1
           munder.last
-        elsif munder.length == 1
-          if munder.first.class_name == "bar"
-            munder.first.swap_class
-          else
-            munder.last
-          end
         else
           Math::Function::Underset.new(
             munder[1],
@@ -336,10 +332,13 @@ module Plurimath
       rule(attributes: subtree(:attrs),
            value: sequence(:value)) do
         approved_attrs = if attrs.is_a?(Hash)
-          attrs.keys.any? { |k| ["accentunder", "accent"].include?(k.to_s) } ? attrs : nil
-        else
-          attrs
-        end
+                           supported_attrs = %w[accentunder accent]
+                           attrs if attrs.keys.any? do |k|
+                             supported_attrs.include?(k.to_s)
+                           end
+                         else
+                           attrs
+                         end
         Utility.join_attr_value(approved_attrs, value&.flatten&.compact)
       end
     end

data/lib/plurimath/omml/transform.rb

@@ -137,8 +137,8 @@ module Plurimath
         chr_value = chr ? chr[:chr] : Math::Function::Hat.new
         index = acc_value.index { |d| d[:chr] }
         acc_value[index] = chr_value
-        Utility.binary_function_classes(acc_value)
-        acc_value.first.parameter_two = { accent: true }
+        Utility.unary_function_classes(acc_value)
+        acc_value.first.attributes = { accent: true }
         acc_value.first
       end
 
@@ -149,12 +149,22 @@ module Plurimath
       end
 
       rule(nary: subtree(:nary)) do
-        Math::Formula.new(
-          [
-            Utility.nary_fonts(nary),
-            Utility.filter_values(nary[3]),
-          ],
-        )
+        flatten_nary = nary.flatten.compact
+        chr = Utility.find_pos_chr(flatten_nary, :chr)
+        ternary_class = Utility.mathml_unary_classes(chr.values) if chr
+        if ternary_class.is_a?(Math::Function::TernaryFunction)
+          ternary_class.parameter_one = Utility.filter_values(nary[1])
+          ternary_class.parameter_two = Utility.filter_values(nary[2])
+          ternary_class.parameter_three = Utility.filter_values(nary[3])
+          ternary_class
+        else
+          Math::Formula.new(
+            [
+              Utility.nary_fonts(nary),
+              Utility.filter_values(nary[3]),
+            ],
+          )
+        end
       end
 
       rule(groupChr: subtree(:groupchr)) do
@@ -175,7 +185,6 @@ module Plurimath
       end
 
       rule(sSubSup: subtree(:sSubSup)) do
-        function_classes = [Math::Formula, Math::Function::FontStyle]
         subsup = sSubSup.flatten.compact
         subsup.each_with_index do |object, ind|
           subsup[ind] = Utility.mathml_unary_classes([object]) if object.is_a?(String)
@@ -235,7 +244,6 @@ module Plurimath
       end
 
       rule(limLow: subtree(:lim)) do
-        flatten_lim = lim.flatten.compact
         second_value = Utility.filter_values(lim[2])
         unicode = Mathml::Constants::UNICODE_SYMBOLS.invert[second_value.class_name]
         second_value = unicode ? Math::Symbol.new(unicode.to_s) : second_value

data/lib/plurimath/utility.rb

@@ -72,7 +72,7 @@ module Plurimath
       max
       min
     ].freeze
-    OMML_FONTS  = {
+    OMML_FONTS = {
       "sans-serif-bi": Math::Function::FontStyle::SansSerifBoldItalic,
       "sans-serif-i": Math::Function::FontStyle::SansSerifItalic,
       "sans-serif-b": Math::Function::FontStyle::BoldSansSerif,
@@ -81,12 +81,24 @@ module Plurimath
       "fraktur-p": Math::Function::FontStyle::Fraktur,
       "fraktur-b": Math::Function::FontStyle::BoldFraktur,
       "script-b": Math::Function::FontStyle::BoldScript,
-      "monospace": Math::Function::FontStyle::Monospace,
       "script-p": Math::Function::FontStyle::Script,
-      "bi": Math::Function::FontStyle::BoldItalic,
-      "p": Math::Function::FontStyle::Normal,
-      "i": Math::Function::FontStyle::Italic,
-      "b": Math::Function::FontStyle::Bold,
+      monospace: Math::Function::FontStyle::Monospace,
+      bi: Math::Function::FontStyle::BoldItalic,
+      p: Math::Function::FontStyle::Normal,
+      i: Math::Function::FontStyle::Italic,
+      b: Math::Function::FontStyle::Bold,
+    }.freeze
+    PARENTHESIS = {
+      "〈": "〉",
+      "⌊": "⌋",
+      "⌈": "⌉",
+      "‖": "‖",
+      "{": "}",
+      "[": "]",
+      "|": "|",
+      "(": ")",
+      "{": "}",
+      "[": "]",
     }.freeze
 
     class << self
@@ -344,7 +356,7 @@ module Plurimath
           value
         elsif attrs.is_a?(String) && ["solid", "none"].include?(attrs.split.first.downcase)
           table_separator(attrs.split, value)
-        elsif attrs.is_a?(Hash) && (attrs.key?(:accent) ||  attrs.key?(:accentunder))
+        elsif attrs.is_a?(Hash) && (attrs.key?(:accent) || attrs.key?(:accentunder))
           attr_is_accent(attrs, value)
         elsif attrs.is_a?(Math::Core)
           attr_is_function(attrs, value)
@@ -352,9 +364,9 @@ module Plurimath
       end
 
       def attr_is_accent(attrs, value)
-        value.last.parameter_one = value.shift if value.length > 1
-        if value.last.is_a?(Math::Function::BinaryFunction)
-          value.last.parameter_two = attrs.transform_values { |v| YAML.load(v) }
+        if value.last.is_a?(Math::Function::UnaryFunction)
+          value.last.parameter_one = value.shift if value.length > 1
+          value.last.attributes = attrs.transform_values { |v| YAML.safe_load(v) }
         end
         value
       end
@@ -470,9 +482,9 @@ module Plurimath
             (
               object.is_a?(Math::Function::TernaryFunction) && object.any_value_exist?
             ) &&
-            mrow.length <= 2
+            (mrow.length <= 2)
           ) ||
-          object.is_a?(Math::Function::UnaryFunction) && mrow.length == 1
+          (object.is_a?(Math::Function::UnaryFunction) && mrow.length == 1)
         )
       end
 
@@ -494,7 +506,7 @@ module Plurimath
           if object.is_a?(Math::Function::Mod)
             next unless mrow.length >= 1
 
-            object.parameter_one = mrow.delete_at(ind - 1) unless ind == 0
+            object.parameter_one = mrow.delete_at(ind - 1) unless ind.zero?
             object.parameter_two = mrow.delete_at(ind)
           elsif Mathml::Constants::UNICODE_SYMBOLS.invert[object.class_name] && mrow.length > 1
             next if object.parameter_one || mrow.length > 2
@@ -510,9 +522,11 @@ module Plurimath
         if mrow.any?(String) || mrow.any?(unary_class)
           mrow.each_with_index do |object, ind|
             mrow[ind] = mathml_unary_classes([object]) if object.is_a?(String)
+            object = mrow[ind] if object.is_a?(String)
             next unless object.is_a?(unary_class)
             next if object.is_a?(Math::Function::Text)
             next if object.parameter_one || mrow[ind + 1].nil?
+            next unless ind.zero?
 
             object.parameter_one = mrow.delete_at(ind + 1)
           end
@@ -533,6 +547,32 @@ module Plurimath
           end
         end
       end
+
+      def paren_able?(arr = [], mrow = [])
+        arr.any? do |opening, closing|
+          symbol_value(mrow.first, opening.to_s) && symbol_value(mrow.last, closing.to_s)
+        end
+      end
+
+      def fenceable_classes(mrow = [])
+        return false unless mrow.length > 1
+
+        if paren_able?(PARENTHESIS, mrow)
+          open_paren = mrow.shift
+          close_paren = mrow.pop
+          if mrow.length == 1 && mrow.first.is_a?(Math::Function::Table)
+            table = mrow.first
+            table.open_paren = open_paren
+            table.close_paren = close_paren
+          else
+            mrow.replace(
+              [
+                Math::Function::Fenced.new(open_paren, mrow.dup, close_paren),
+              ],
+            )
+          end
+        end
+      end
     end
   end
 end

data/lib/plurimath/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Plurimath
-  VERSION = "0.4.1"
+  VERSION = "0.4.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: plurimath
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.4.2
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-08-24 00:00:00.000000000 Z
+date: 2023-08-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parslet