plurimath 0.3.8 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 78fffd236ecb53260b07fa02ce5cc2254d3835a6491229a7acc50c2a2ed80dbb
-  data.tar.gz: e17acb1342c8b5a7f5de3b8496962a12264404f9dd8902a42c47069a6ad0a157
+  metadata.gz: 0ae20aeedcb99f6b913e591de0bf18624aae42c750df4ea706d90a6c47be4193
+  data.tar.gz: d1e9513bd715e585b57fffc72f1c0a6e163b6ac7ea4d270fe2e8323301f89036
 SHA512:
-  metadata.gz: a66739db5ef92081d8c73af2bbebaf77aa03bab5f8befbd14a9a80bdb4eea4d8c03e996dbc0aedbb5cf16c0bd90189a32dde1d67925c646f02cec6423e532f3c
-  data.tar.gz: 81e43972fead184a05ebc04948bba6433fef1ce6824223bd59b8a89d08c2ac41f4adbcb41e00426dd2d9dad6d6ff04a0ec2fc34ba7f51a7457f258b5087e0e72
+  metadata.gz: 6532186819c4523f46d6dc3503df5b88972f5c68cb54a3bd3e7ff66a1d8bd6d8b4346eac33a0ef2504bfcb4a1f813eb7130e9bb55b8196e3b2878b0733c7dad0
+  data.tar.gz: c9cbda12a71c9e0e57c04a92737945eef6ff79a6cbc35c3e0bdc7b0eddc0443af0e8614bd5d803db64de7e036b385324fe5f0c91a5faa3c601886d63eade5325

data/lib/plurimath/asciimath/transform.rb

@@ -766,6 +766,18 @@ module Plurimath
         )
       end
 
+      rule(ternary_class: simple(:function),
+           base_value: simple(:base),
+           power_value: simple(:power),
+           third_value: sequence(:third)) do
+        third_value = third.is_a?(Slice) ? nil : third
+        Utility.get_class(function).new(
+          Utility.unfenced_value(base),
+          Utility.unfenced_value(power),
+          Utility.filter_values(third_value),
+        )
+      end
+
       rule(unary_class: simple(:function),
            intermediate_exp: simple(:int_exp)) do
         first_value = if Utility::UNARY_CLASSES.include?(function)
@@ -821,6 +833,11 @@ module Plurimath
         expr.insert(0, ternary)
       end
 
+      rule(ternary: simple(:ternary),
+           left_right: simple(:left_right)) do
+        [ternary, left_right]
+      end
+
       rule(unary_class: simple(:function),
            text: simple(:text)) do
         Utility.get_class(function).new(

data/lib/plurimath/math/core.rb

@@ -7,14 +7,18 @@ module Plurimath
         self.class.name.split("::").last.downcase
       end
 
-      def insert_t_tag
-        Array(to_omml_without_math_tag)
+      def insert_t_tag(display_style)
+        Array(to_omml_without_math_tag(display_style))
       end
 
       def tag_name
         "subsup"
       end
 
+      def omml_tag_name
+        "subSup"
+      end
+
       def nary_attr_value
         ""
       end
@@ -25,13 +29,13 @@ module Plurimath
         wrapper_tag << r_tag
       end
 
-      def omml_parameter(field, tag_name: , namespace: "m")
+      def omml_parameter(field, display_style, tag_name: , namespace: "m")
         tag = Utility.ox_element(tag_name, namespace: namespace)
         return empty_tag(tag) unless field
 
         Utility.update_nodes(
           tag,
-          field&.insert_t_tag,
+          field&.insert_t_tag(display_style),
         )
       end
 
@@ -48,6 +52,18 @@ module Plurimath
         r_tag << (Utility.ox_element("t", namespace: "m") << string)
         Array(r_tag)
       end
+
+      def extractable?
+        false
+      end
+
+      def extract_class_from_text
+        ""
+      end
+
+      def font_style_t_tag(display_style)
+        to_omml_without_math_tag(display_style)
+      end
     end
   end
 end

data/lib/plurimath/math/formula.rb

@@ -3,17 +3,18 @@
 module Plurimath
   module Math
     class Formula < Core
-      attr_accessor :value, :left_right_wrapper, :displaystyle
+      attr_accessor :value, :left_right_wrapper, :displaystyle, :input_string
 
       def initialize(
         value = [],
         left_right_wrapper = true,
-        displaystyle: true
+        display_style: true,
+        input_string: nil
       )
         @value = value.is_a?(Array) ? value : [value]
         left_right_wrapper = false if @value.first.is_a?(Function::Left)
         @left_right_wrapper = left_right_wrapper
-        @displaystyle = displaystyle
+        @displaystyle = boolean_display_style(display_style)
       end
 
       def ==(object)
@@ -23,6 +24,8 @@ module Plurimath
 
       def to_asciimath
         value.map(&:to_asciimath).join(" ")
+      rescue
+        parse_error!(:asciimath)
       end
 
       def to_mathml(display_style: displaystyle)
@@ -30,12 +33,14 @@ module Plurimath
           xmlns: "http://www.w3.org/1998/Math/MathML",
           display: "block",
         }
-        style_attrs = { displaystyle: display_style }
+        style_attrs = { displaystyle: boolean_display_style(display_style) }
         math  = Utility.ox_element("math", attributes: math_attrs)
         style = Utility.ox_element("mstyle", attributes: style_attrs)
         Utility.update_nodes(style, mathml_content)
         Utility.update_nodes(math, [style])
         Ox.dump(math, indent: 2).gsub("&amp;", "&")
+      rescue
+        parse_error!(:mathml)
       end
 
       def to_mathml_without_math_tag
@@ -53,10 +58,14 @@ module Plurimath
 
       def to_latex
         value&.map(&:to_latex)&.join(" ")
+      rescue
+        parse_error!(:latex)
       end
 
       def to_html
         value&.map(&:to_html)&.join(" ")
+      rescue
+        parse_error!(:html)
       end
 
       def omml_math_attrs
@@ -82,41 +91,39 @@ module Plurimath
         }
       end
 
-      def to_omml
+      def to_omml(display_style: displaystyle)
         para_element = Utility.ox_element(
           "oMathPara",
           attributes: omml_math_attrs,
           namespace: "m",
         )
         math_element = Utility.ox_element("oMath", namespace: "m")
-        Utility.update_nodes(math_element, omml_content)
-        Utility.update_nodes(para_element, Array(math_element))
+        content = omml_content(boolean_display_style(display_style))
+        para_element << Utility.update_nodes(math_element, content)
         Ox.dump(para_element, indent: 2).gsub("&amp;", "&").lstrip
+      rescue
+        parse_error!(:omml)
       end
 
-      def omml_content
-        value&.map(&:insert_t_tag)
+      def omml_content(display_style)
+        value&.map { |val| val.insert_t_tag(display_style) }
       end
 
-      def to_omml_without_math_tag
-        return nary_tag if nary_tag_able?
+      def to_omml_without_math_tag(display_style)
+        return nary_tag(display_style) if nary_tag_able?(display_style)
 
-        omml_content
+        omml_content(display_style)
       end
 
-      def nary_tag
-        nary_tag = Utility.ox_element("nary", namespace: "m")
+      def nary_tag(display_style)
+        nary_element = Utility.ox_element("nary", namespace: "m")
         e_tag    = Utility.ox_element("e", namespace: "m")
-        Utility.update_nodes(e_tag, value.last.insert_t_tag)
+        Utility.update_nodes(e_tag, value.last.insert_t_tag(display_style))
         Utility.update_nodes(
-          nary_tag,
-          (value.first.omml_nary_tag << e_tag),
+          nary_element,
+          (value.first.omml_nary_tag(display_style) << e_tag),
         )
-        [nary_tag]
-      end
-
-      def class_name
-        self.class.name.split("::").last.downcase
+        [nary_element]
       end
 
       def extract_class_from_text
@@ -129,18 +136,28 @@ module Plurimath
         value.first.nary_attr_value
       end
 
-      def nary_tag_able?
+      def nary_tag_able?(display_style)
         value.length == 2 &&
           ["underover", "powerbase"].include?(value&.first&.class_name) &&
           (
-            value&.first&.parameter_one&.to_omml_without_math_tag&.length == 1 ||
-            value&.first&.parameter_one.to_omml_without_math_tag.match?(/^&#x\w*\d*;$/)
+            value&.first&.parameter_one&.to_omml_without_math_tag(display_style)&.length == 1 ||
+            value&.first&.parameter_one.to_omml_without_math_tag(display_style).match?(/^&#x\w*\d*;$/)
           )
       end
 
       def validate_function_formula
         (value.none?(Function::Left) || value.none?(Function::Right))
       end
+
+      protected
+
+      def boolean_display_style(display_style = displaystyle)
+        YAML.load(display_style.to_s)
+      end
+
+      def parse_error!(type)
+        Math.parse_error!(input_string, type)
+      end
     end
   end
 end

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

@@ -15,10 +15,10 @@ module Plurimath
           )
         end
 
-        def to_omml_without_math_tag
+        def to_omml_without_math_tag(display_style)
           md = (Utility.ox_element("d", namespace: "m") << mdpr_tag)
           me = Utility.ox_element("e", namespace: "m")
-          Utility.update_nodes(me, omml_value)
+          Utility.update_nodes(me, omml_value(display_style))
           Utility.update_nodes(md, Array(me))
           [md]
         end

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

@@ -1,43 +1,74 @@
 # frozen_string_literal: true
 
-require_relative "unary_function"
+require_relative "binary_function"
 
 module Plurimath
   module Math
     module Function
-      class Bar < UnaryFunction
+      class Bar < BinaryFunction
+        def to_asciimath
+          first_value = "(#{parameter_one.to_asciimath})" if parameter_one
+          "bar#{first_value}"
+        end
+
         def to_latex
           first_value = "{#{parameter_one.to_latex}}" if parameter_one
           "\\overline#{first_value}"
         end
 
         def to_mathml_without_math_tag
-          first_value = parameter_one&.to_mathml_without_math_tag
+          mo_tag = Utility.ox_element("mo") << "&#xaf;"
+          return mo_tag unless parameter_one
+
+          mover_tag = Utility.ox_element("mover")
+          mover_tag.attributes.merge!(parameter_two) if parameter_two && !parameter_two.empty?
+          Utility.update_nodes(
+            mover_tag,
+            [
+              parameter_one&.to_mathml_without_math_tag,
+              mo_tag,
+            ],
+          )
+        end
+
+        def to_omml_without_math_tag(display_style)
+          return r_element("&#xaf;", rpr_tag: false) unless all_values_exist?
+
+          parameter_two && parameter_two[:accent] ? acc_tag(display_style) : bar_tag(display_style)
+        end
+
+        def swap_class
+          Ul.new(parameter_one, parameter_two)
+        end
+
+        protected
+
+        def acc_tag(display_style)
+          acc = Utility.ox_element("acc", namespace: "m")
+          chr = Utility.ox_element("chr", namespace: "m", attributes: { "m:val": "‾" } )
+          acc_pr = (Utility.ox_element("accPr", namespace: "m") << chr)
           Utility.update_nodes(
-            Utility.ox_element("mover"),
+            acc,
             [
-              first_value,
-              Utility.ox_element("mo") << "&#xaf;",
+              acc_pr,
+              omml_parameter(parameter_one, display_style, tag_name: "e"),
             ],
           )
+          [acc]
         end
 
-        def to_omml_without_math_tag
+        def bar_tag(display_style)
           bar = Utility.ox_element("bar", namespace: "m")
-          me  = Utility.ox_element("e", namespace: "m")
-          Utility.update_nodes(me, omml_value) if parameter_one
           Utility.update_nodes(
             bar,
             [
               bar_pr,
-              me,
+              omml_parameter(parameter_one, display_style, tag_name: "e", namespace: "m"),
             ],
           )
           [bar]
         end
 
-        protected
-
         def bar_pr
           attrs = { "m:val": "top" }
           barpr = Utility.ox_element("barPr", namespace: "m")

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

@@ -34,7 +34,7 @@ module Plurimath
           "#{first_value}#{second_value}"
         end
 
-        def to_omml_without_math_tag
+        def to_omml_without_math_tag(display_style)
           ssub_element  = Utility.ox_element("sSub", namespace: "m")
           subpr_element = Utility.ox_element("sSubPr", namespace: "m")
           subpr_element << Utility.pr_element("ctrl", true, namespace: "m")
@@ -42,8 +42,8 @@ module Plurimath
             ssub_element,
             [
               subpr_element,
-              omml_parameter(parameter_one, tag_name: "e"),
-              omml_parameter(parameter_two, tag_name: "sub"),
+              omml_parameter(parameter_one, display_style, tag_name: "e"),
+              omml_parameter(parameter_two, display_style, tag_name: "sub"),
             ],
           )
           [ssub_element]

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

@@ -49,13 +49,17 @@ module Plurimath
           "#{first_value}#{second_value}"
         end
 
-        def to_omml_without_math_tag
+        def to_omml_without_math_tag(display_style)
           r_tag = Utility.ox_element("r", namespace: "m")
-          Utility.update_nodes(r_tag, [parameter_one.insert_t_tag]) if parameter_one
-          Utility.update_nodes(r_tag, [parameter_two.insert_t_tag]) if parameter_two
+          Utility.update_nodes(r_tag, [parameter_one.insert_t_tag(display_style)]) if parameter_one
+          Utility.update_nodes(r_tag, [parameter_two.insert_t_tag(display_style)]) if parameter_two
           [r_tag]
         end
 
+        def all_values_exist?
+          !(parameter_one.nil? && parameter_two.nil?)
+        end
+
         protected
 
         def latex_wrapped(field)
@@ -82,8 +86,20 @@ module Plurimath
           wrapper_tag << r_tag
         end
 
-        def all_values_exist?
-          !parameter_one.nil? && !parameter_two.nil?
+        def underover(display_style)
+          return r_element(class_name, rpr_tag: false) unless all_values_exist?
+
+          first_value = Symbol.new(class_name)
+          if !display_style
+            power_base = PowerBase.new(first_value, parameter_one, parameter_two)
+            return power_base.to_omml_without_math_tag(display_style)
+          end
+
+          overset = Overset.new(first_value, parameter_two)
+          return Array(overset.to_omml_without_math_tag(display_style)) unless parameter_one
+
+          underset = Underset.new(overset, parameter_one)
+          Array(underset.to_omml_without_math_tag(display_style))
         end
       end
     end

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

@@ -15,8 +15,8 @@ module Plurimath
           Utility.update_nodes(cancel_tag, [first_value])
         end
 
-        def to_omml_without_math_tag
-          omml_value
+        def to_omml_without_math_tag(display_style)
+          omml_value(display_style)
         end
       end
     end

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

@@ -20,11 +20,16 @@ module Plurimath
           )
         end
 
-        def to_omml_without_math_tag
+        def to_omml_without_math_tag(display_style)
           lceil = Symbol.new("⌈")
           rceil = Symbol.new("⌉")
           fenced = Fenced.new(lceil, Array(parameter_one), rceil)
-          Array(fenced.to_omml_without_math_tag)
+          Array(fenced.to_omml_without_math_tag(display_style))
+        end
+
+        def to_html
+          first_value = "<i>#{parameter_one.to_html}</i>" if parameter_one
+          "<i>&#x2308;</i>#{first_value}<i>&#x2309;</i>"
         end
       end
     end

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

@@ -28,8 +28,8 @@ module Plurimath
           "{\\#{class_name}{#{first_value}} #{second_value}}"
         end
 
-        def to_omml_without_math_tag
-          Array(parameter_two.insert_t_tag)
+        def to_omml_without_math_tag(display_style)
+          Array(parameter_two.insert_t_tag(display_style))
         end
       end
     end

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

@@ -14,18 +14,16 @@ module Plurimath
           )
         end
 
-        def to_omml_without_math_tag
-          acc_tag    = Utility.ox_element("acc", namespace: "m")
-          acc_pr_tag = Utility.ox_element("accPr", namespace: "m")
-          acc_pr_tag << (Utility.ox_element("chr", namespace: "m", attributes: { "m:val": ".." }))
-          Utility.update_nodes(
-            acc_tag,
-            [
-              acc_pr_tag,
-              omml_parameter(parameter_one, tag_name: "e"),
-            ],
-          )
-          [acc_tag]
+        def to_omml_without_math_tag(display_style)
+          return r_element("..", rpr_tag: false) unless parameter_one
+
+          symbol = Symbol.new("..")
+          Overset.new(parameter_one, symbol).to_omml_without_math_tag(true)
+        end
+
+        def to_html
+          first_value = "<i>#{parameter_one.to_html}</i>" if parameter_one
+          "#{first_value}<i>..</i>"
         end
       end
     end

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

@@ -10,8 +10,8 @@ module Plurimath
           false
         end
 
-        def to_omml_without_math_tag
-          [r_element("deg"), omml_value]
+        def to_omml_without_math_tag(display_style)
+          [r_element("deg", rpr_tag: false), omml_value(display_style)]
         end
       end
     end

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

@@ -10,8 +10,8 @@ module Plurimath
           false
         end
 
-        def to_omml_without_math_tag
-          [r_element("det"), omml_value]
+        def to_omml_without_math_tag(display_style)
+          [r_element("det", rpr_tag: false), omml_value(display_style)]
         end
       end
     end

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

@@ -10,8 +10,8 @@ module Plurimath
           false
         end
 
-        def to_omml_without_math_tag
-          [r_element("dim"), omml_value]
+        def to_omml_without_math_tag(display_style)
+          [r_element("dim", rpr_tag: false), omml_value(display_style)]
         end
       end
     end

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

@@ -1,15 +1,19 @@
 # frozen_string_literal: true
 
-require_relative "unary_function"
+require_relative "binary_function"
 
 module Plurimath
   module Math
     module Function
-      class Dot < UnaryFunction
+      class Dot < BinaryFunction
         def to_mathml_without_math_tag
+          dot_tag = (Utility.ox_element("mo") << ".")
+          return dot_tag unless all_values_exist?
+
           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
           Utility.update_nodes(
             over_tag,
             [
@@ -19,7 +23,20 @@ module Plurimath
           )
         end
 
-        def to_omml_without_math_tag
+        def to_omml_without_math_tag(display_style)
+          return r_element(".", rpr_tag: false) unless all_values_exist?
+
+          if parameter_two && parameter_two[:accent]
+            acc_tag(display_style)
+          else
+            symbol = Symbol.new(".")
+            Overset.new(parameter_one, symbol).to_omml_without_math_tag(true)
+          end
+        end
+
+        protected
+
+        def acc_tag(display_style)
           acc_tag    = Utility.ox_element("acc", namespace: "m")
           acc_pr_tag = Utility.ox_element("accPr", namespace: "m")
           acc_pr_tag << Utility.ox_element(
@@ -31,7 +48,7 @@ module Plurimath
             acc_tag,
             [
               acc_pr_tag,
-              omml_parameter(parameter_one, tag_name: "e"),
+              omml_parameter(parameter_one, display_style, tag_name: "e"),
             ],
           )
           [acc_tag]

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

@@ -10,8 +10,8 @@ module Plurimath
           false
         end
 
-        def to_omml_without_math_tag
-          [r_element("exp"), omml_value]
+        def to_omml_without_math_tag(display_style)
+          [r_element("exp", rpr_tag: false), omml_value(display_style)]
         end
       end
     end

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

@@ -38,7 +38,7 @@ module Plurimath
           "#{first_value} #{fenced_value} #{second_value}"
         end
 
-        def to_omml_without_math_tag
+        def to_omml_without_math_tag(display_style)
           d = Utility.ox_element("d", namespace: "m")
           dpr = Utility.ox_element("dPr", namespace: "m")
           first_value(dpr)
@@ -50,6 +50,7 @@ module Plurimath
               dpr,
               omml_parameter(
                 Formula.new(Array(parameter_two)),
+                display_style,
                 tag_name: "e",
               ),
             ],

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

@@ -22,10 +22,10 @@ module Plurimath
           )
         end
 
-        def to_omml_without_math_tag
+        def to_omml_without_math_tag(display_style)
           [
             r_element("⌊"),
-            omml_value,
+            omml_value(display_style),
             r_element("⌋"),
           ]
         end

data/lib/plurimath/math/function/font_style/bold-fraktur.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative "../font_style"
+
+module Plurimath
+  module Math
+    module Function
+      class FontStyle
+        class BoldFraktur < FontStyle
+          def to_omml_without_math_tag(display_style)
+            font_styles(display_style, sty: "b", scr: "fraktur")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/plurimath/math/function/font_style/bold-italic.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative "../font_style"
+
+module Plurimath
+  module Math
+    module Function
+      class FontStyle
+        class BoldItalic < FontStyle
+          def to_omml_without_math_tag(display_style)
+            font_styles(display_style, sty: "bi")
+          end
+        end
+      end
+    end
+  end
+end