plurimath 0.10.2 → 0.10.3

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

@@ -1,12 +1,13 @@
 # frozen_string_literal: true
 
-
 module Plurimath
   module Math
     module Function
       class Msgroup < UnaryFunction
         def to_asciimath(options:)
-          parameter_one.map { |param| param.to_asciimath(options: options) }.join
+          parameter_one.map do |param|
+            param.to_asciimath(options: options)
+          end.join
         end
 
         def to_latex(options:)
@@ -16,7 +17,9 @@ module Plurimath
         def to_mathml_without_math_tag(intent, options:)
           Utility.update_nodes(
             Utility.ox_element("msgroup"),
-            parameter_one.map { |object| object&.to_mathml_without_math_tag(intent, options: options) },
+            parameter_one.map do |object|
+              object&.to_mathml_without_math_tag(intent, options: options)
+            end,
           )
         end
 
@@ -28,50 +31,64 @@ module Plurimath
           "<i>#{parameter_one.map(&:to_html).join}</i>"
         end
 
-        def to_asciimath_math_zone(spacing, last = false, _indent = true, options:)
+        def to_asciimath_math_zone(spacing, last = false, _indent = true,
+options:)
           [
             "#{spacing}\"msgroup\" function apply\n",
-            Formula.new(parameter_one).to_asciimath_math_zone(gsub_spacing(spacing, last), options: options),
+            Formula.new(parameter_one).to_asciimath_math_zone(
+              gsub_spacing(spacing, last), options: options
+            ),
           ]
         end
 
         def to_latex_math_zone(spacing, last = false, indent = true, options:)
           [
             "#{spacing}\"msgroup\" function apply\n",
-            Formula.new(parameter_one).to_latex_math_zone(gsub_spacing(spacing, last), last, indent, options: options),
+            Formula.new(parameter_one).to_latex_math_zone(
+              gsub_spacing(spacing, last), last, indent, options: options
+            ),
           ]
         end
 
         def to_mathml_math_zone(spacing, last = false, indent = true, options:)
           [
             "#{spacing}\"msgroup\" function apply\n",
-            Formula.new(parameter_one).to_mathml_math_zone(gsub_spacing(spacing, last), last, indent, options: options),
+            Formula.new(parameter_one).to_mathml_math_zone(
+              gsub_spacing(spacing, last), last, indent, options: options
+            ),
           ]
         end
 
-        def to_omml_math_zone(spacing, last = false, indent = true, display_style:, options:)
+        def to_omml_math_zone(spacing, last = false, indent = true,
+display_style:, options:)
           [
             "#{spacing}\"msgroup\" function apply\n",
-            Formula.new(parameter_one).to_omml_math_zone(gsub_spacing(spacing, last), last, indent, display_style: display_style, options: options),
+            Formula.new(parameter_one).to_omml_math_zone(
+              gsub_spacing(spacing,
+                           last), last, indent, display_style: display_style, options: options
+            ),
           ]
         end
 
-        def to_unicodemath_math_zone(spacing, last = false, indent = true, options:)
+        def to_unicodemath_math_zone(spacing, last = false, indent = true,
+options:)
           [
             "#{spacing}\"msgroup\" function apply\n",
-            Formula.new(parameter_one).to_unicodemath_math_zone(gsub_spacing(spacing, last), last, indent, options: options),
+            Formula.new(parameter_one).to_unicodemath_math_zone(
+              gsub_spacing(spacing, last), last, indent, options: options
+            ),
           ]
         end
 
         def to_unicodemath(options:)
-          parameter_one.map { |param| param.to_unicodemath(options: options) }.join
+          parameter_one.map do |param|
+            param.to_unicodemath(options: options)
+          end.join
         end
 
         def line_breaking(obj)
           custom_array_line_breaking(obj)
         end
-
-        private
       end
     end
   end

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

@@ -1,22 +1,20 @@
 # frozen_string_literal: true
 
-
 module Plurimath
   module Math
     module Function
       class Msline < UnaryFunction
-
         def to_asciimath(**); end
 
         def to_latex(**); end
 
-        def to_mathml_without_math_tag(intent, **)
+        def to_mathml_without_math_tag(_intent, **)
           ox_element("msline")
         end
 
-        def to_omml_without_math_tag(display_style, **);end
+        def to_omml_without_math_tag(display_style, **); end
 
-        def to_unicodemath(**);end
+        def to_unicodemath(**); end
       end
     end
   end

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

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-
 module Plurimath
   module Math
     module Function
@@ -13,15 +12,31 @@ module Plurimath
         }.freeze
 
         def to_asciimath(options:)
-          subscript = "_(#{parameter_two&.map { |param| param.to_asciimath(options: options) }.join})" unless valid_value_exist?(parameter_two)
-          supscript = "^(#{parameter_three&.map { |param| param.to_asciimath(options: options) }.join})" unless valid_value_exist?(parameter_three)
+          unless valid_value_exist?(parameter_two)
+            subscript = "_(#{parameter_two&.map do |param|
+              param.to_asciimath(options: options)
+            end&.join})"
+          end
+          unless valid_value_exist?(parameter_three)
+            supscript = "^(#{parameter_three&.map do |param|
+              param.to_asciimath(options: options)
+            end&.join})"
+          end
           prescript = "\\ #{subscript}#{supscript}" if subscript || supscript
           "#{prescript}#{parameter_one&.to_asciimath(options: options)}"
         end
 
         def to_latex(options:)
-          subscript = "_{#{parameter_two&.map { |param| param.to_latex(options: options) }&.join}}" unless valid_value_exist?(parameter_two)
-          supscript = "^{#{parameter_three&.map { |param| param.to_latex(options: options) }&.join}}" unless valid_value_exist?(parameter_three)
+          unless valid_value_exist?(parameter_two)
+            subscript = "_{#{parameter_two&.map do |param|
+              param.to_latex(options: options)
+            end&.join}}"
+          end
+          unless valid_value_exist?(parameter_three)
+            supscript = "^{#{parameter_three&.map do |param|
+              param.to_latex(options: options)
+            end&.join}}"
+          end
           prescript = "{}#{subscript}#{supscript}" if subscript || supscript
           "#{prescript}#{parameter_one&.to_latex(options: options)}"
         end
@@ -34,7 +49,7 @@ module Plurimath
               parameter_one&.mmultiscript(intent, options: options),
               mprescript,
               validate_mathml_fields(prescripts, intent, options: options),
-            ]
+            ],
           )
         end
 
@@ -42,9 +57,12 @@ module Plurimath
           Utility.update_nodes(
             ox_element("sPre", namespace: "m"),
             [
-              omml_parameter(parameter_one, display_style, tag_name: "e", options: options),
-              omml_parameter(parameter_two, display_style, tag_name: "sub", options: options),
-              omml_parameter(parameter_three, display_style, tag_name: "sup", options: options),
+              omml_parameter(parameter_one, display_style, tag_name: "e",
+                                                           options: options),
+              omml_parameter(parameter_two, display_style, tag_name: "sub",
+                                                           options: options),
+              omml_parameter(parameter_three, display_style, tag_name: "sup",
+                                                             options: options),
             ],
           )
         end
@@ -59,7 +77,8 @@ module Plurimath
           parameter_one&.line_breaking(obj)
           if obj.value_exist?
             obj.update(
-              self.class.new(Utility.filter_values(obj.value), parameter_two, parameter_three)
+              self.class.new(Utility.filter_values(obj.value), parameter_two,
+                             parameter_three),
             )
             self.parameter_two = nil
             self.parameter_three = nil
@@ -73,7 +92,7 @@ module Plurimath
           )
           if obj.value_exist?
             obj.update(
-              self.class.new(nil, obj.value, parameter_three)
+              self.class.new(nil, obj.value, parameter_three),
             )
             self.parameter_three = nil
           end
@@ -86,7 +105,9 @@ module Plurimath
           return parameter_two if parameter_three.nil? || parameter_three.empty?
 
           prescripts_array = []
-          Array(parameter_two).zip(Array(parameter_three)) { |array| prescripts_array << array }
+          Array(parameter_two).zip(Array(parameter_three)) do |array|
+            prescripts_array << array
+          end
           prescripts_array.flatten.compact
         end
 
@@ -100,7 +121,9 @@ module Plurimath
 
         def sup_value(options:)
           field = Utility.filter_values(parameter_two)
-          field_value = parameter_three.map { |param| param.to_unicodemath(options: options) }.join
+          field_value = parameter_three.map do |param|
+            param.to_unicodemath(options: options)
+          end.join
           if field&.mini_sized? || prime_unicode?(field)
             field_value
           elsif field.is_a?(Math::Function::Power)
@@ -112,7 +135,9 @@ module Plurimath
 
         def sub_value(options:)
           field = Utility.filter_values(parameter_two)
-          field_value = parameter_two&.map { |param| param.to_unicodemath(options: options) }.join
+          field_value = parameter_two&.map do |param|
+            param.to_unicodemath(options: options)
+          end&.join
           if field&.mini_sized?
             field_value
           elsif parameter_two.is_a?(Math::Function::Base)

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

@@ -4,7 +4,8 @@ module Plurimath
   module Math
     module Function
       class Nary < Core
-        attr_accessor :parameter_one, :parameter_two, :parameter_three, :parameter_four, :options
+        attr_accessor :parameter_one, :parameter_two, :parameter_three,
+                      :parameter_four, :options
 
         def initialize(parameter_one = nil,
                        parameter_two = nil,
@@ -16,7 +17,8 @@ module Plurimath
           @parameter_three = parameter_three
           @parameter_four = parameter_four
           @options = options
-          Utility.validate_left_right([parameter_one, parameter_two, parameter_three, parameter_four])
+          Utility.validate_left_right([parameter_one, parameter_two,
+                                       parameter_three, parameter_four])
         end
 
         def ==(object)
@@ -51,7 +53,7 @@ module Plurimath
             validate_mathml_fields(parameter_three, intent, options: options),
           ]
           subsup_tag = Utility.update_nodes(ox_element(tag_name), new_arr)
-          masked_tag(subsup_tag) if self.options.dig(:mask)
+          masked_tag(subsup_tag) if self.options[:mask]
           return subsup_tag unless parameter_four
 
           intentify(
@@ -59,7 +61,10 @@ module Plurimath
               ox_element("mrow"),
               [
                 subsup_tag,
-                wrap_mrow(validate_mathml_fields(parameter_four, intent, options: options), true),
+                wrap_mrow(
+                  validate_mathml_fields(parameter_four, intent,
+                                         options: options), true
+                ),
               ],
             ),
             intent,
@@ -70,7 +75,8 @@ module Plurimath
 
         def to_omml_without_math_tag(display_style, options:)
           nary_element = Utility.ox_element("nary", namespace: "m")
-          Utility.update_nodes(nary_element, omml_nary_tag(display_style, options: options))
+          Utility.update_nodes(nary_element,
+                               omml_nary_tag(display_style, options: options))
           Array(nary_element)
         end
 
@@ -78,9 +84,13 @@ module Plurimath
           first_value = sub_value(options: options) if parameter_two
           second_value = sup_value(options: options) if parameter_three
           if prime_unicode?(parameter_three)
-            "#{parameter_one&.to_unicodemath(options: options)}#{second_value}#{first_value}#{naryand_value(parameter_four, options: options)}"
+            "#{parameter_one&.to_unicodemath(options: options)}#{second_value}#{first_value}#{naryand_value(
+              parameter_four, options: options
+            )}"
           else
-            "#{parameter_one&.to_unicodemath(options: options)}#{first_value}#{second_value}#{naryand_value(parameter_four, options: options)}"
+            "#{parameter_one&.to_unicodemath(options: options)}#{first_value}#{second_value}#{naryand_value(
+              parameter_four, options: options
+            )}"
           end
         end
 
@@ -90,11 +100,11 @@ module Plurimath
             obj.update(
               self.class.new(
                 Utility.filter_values(obj.value),
-                self.parameter_two,
-                self.parameter_three,
-                self.parameter_four,
-                self.options,
-              )
+                parameter_two,
+                parameter_three,
+                parameter_four,
+                options,
+              ),
             )
             self.parameter_two = nil
             self.parameter_three = nil
@@ -108,10 +118,10 @@ module Plurimath
               self.class.new(
                 nil,
                 Utility.filter_values(obj.value),
-                self.parameter_three,
-                self.parameter_four,
-                self.options
-              )
+                parameter_three,
+                parameter_four,
+                options,
+              ),
             )
             self.parameter_three = nil
             self.parameter_four = nil
@@ -131,7 +141,8 @@ module Plurimath
 
             intent_name = sym_instance.nary_intent_name
             next pp symbol.const_source_location(:INPUT) if intent_name.nil?
-            hash[intent_name.gsub(/\s|-/, '_').to_sym] = intent_name
+
+            hash[intent_name.gsub(/\s|-/, "_").to_sym] = intent_name
           end
         end
 
@@ -143,9 +154,13 @@ module Plurimath
 
         def chr_value(narypr, options:)
           first_value = Utility.html_entity_to_unicode(parameter_one&.nary_attr_value(options: options))
-          narypr << Utility.ox_element("chr", namespace: "m", attributes: { "m:val": first_value }) unless first_value == "∫"
+          unless first_value == "∫"
+            narypr << Utility.ox_element("chr", namespace: "m",
+                                                attributes: { "m:val": first_value })
+          end
 
-          narypr << Utility.ox_element("limLoc", namespace: "m", attributes: { "m:val": (self.options[:type] || "subSup").to_s })
+          narypr << Utility.ox_element("limLoc", namespace: "m",
+                                                 attributes: { "m:val": (self.options[:type] || "subSup").to_s })
           hide_tags(narypr, parameter_two, "sub")
           hide_tags(narypr, parameter_three, "sup")
           narypr
@@ -154,7 +169,8 @@ module Plurimath
         def hide_tags(nar, field, tag_prefix)
           return nar unless field.nil?
 
-          nar << Utility.ox_element("#{tag_prefix}Hide", namespace: "m", attributes: { "m:val": "1" })
+          nar << Utility.ox_element("#{tag_prefix}Hide", namespace: "m",
+                                                         attributes: { "m:val": "1" })
         end
 
         def omml_nary_tag(display_style, options:)
@@ -162,9 +178,12 @@ module Plurimath
           chr_value(narypr, options: options)
           [
             (narypr << Utility.pr_element("ctrl", true, namespace: "m")),
-            omml_parameter(parameter_two, display_style, tag_name: "sub", options: options),
-            omml_parameter(parameter_three, display_style, tag_name: "sup", options: options),
-            omml_parameter(parameter_four, display_style, tag_name: "e", options: options),
+            omml_parameter(parameter_two, display_style, tag_name: "sub",
+                                                         options: options),
+            omml_parameter(parameter_three, display_style, tag_name: "sup",
+                                                           options: options),
+            omml_parameter(parameter_four, display_style, tag_name: "e",
+                                                          options: options),
           ]
         end
 
@@ -199,16 +218,14 @@ module Plurimath
 
         def tag_name
           tag = options[:type] == "undOvr" ? "munderover" : "msubsup"
-          if !(parameter_two && parameter_three)
-            if parameter_two
-              tag == "munderover" ? "munder" : "msub"
-            elsif parameter_three
-              tag == "munderover" ? "mover" : "msup"
-            else
-             'mrow'
-            end
-          else
+          if parameter_two && parameter_three
             tag
+          elsif parameter_two
+            tag == "munderover" ? "munder" : "msub"
+          elsif parameter_three
+            tag == "munderover" ? "mover" : "msup"
+          else
+            "mrow"
           end
         end
 

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

@@ -1,11 +1,9 @@
 # frozen_string_literal: true
 
-
 module Plurimath
   module Math
     module Function
       class None < UnaryFunction
-
         def to_asciimath(**); end
 
         def to_latex(**); end

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

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-
 module Plurimath
   module Math
     module Function
@@ -16,9 +15,10 @@ module Plurimath
         end
 
         def to_mathml_without_math_tag(intent, options:)
-          first_value = Array(parameter_one&.to_mathml_without_math_tag(intent, options: options))
+          first_value = Array(parameter_one&.to_mathml_without_math_tag(intent,
+                                                                        options: options))
           norm = ox_element("mo") << "&#x2225;"
-          first_value = first_value.insert(0, norm) unless open_paren
+          first_value.insert(0, norm) unless open_paren
           first_value = first_value << norm unless close_paren
           Utility.update_nodes(ox_element("mrow"), first_value)
         end

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

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-
 module Plurimath
   module Math
     module Function
@@ -31,7 +30,8 @@ module Plurimath
           Utility.update_nodes(
             over_tag,
             [
-              parameter_one.to_mathml_without_math_tag(intent, options: options),
+              parameter_one.to_mathml_without_math_tag(intent,
+                                                       options: options),
               mo_tag,
             ],
           )
@@ -48,7 +48,8 @@ module Plurimath
             acc_tag(display_style, options: options)
           else
             symbol = Symbols::Symbol.new("⏞")
-            Overset.new(parameter_one, symbol).to_omml_without_math_tag(true, options: options)
+            Overset.new(parameter_one, symbol).to_omml_without_math_tag(true,
+                                                                        options: options)
           end
         end
 
@@ -66,12 +67,14 @@ module Plurimath
         def acc_tag(display_style, options:)
           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": "⏞" }))
+          acc_pr_tag << Utility.ox_element("chr", namespace: "m",
+                                                  attributes: { "m:val": "⏞" })
           Utility.update_nodes(
             acc_tag,
             [
               acc_pr_tag,
-              omml_parameter(parameter_one, display_style, tag_name: "e", namespace: "m", options: options),
+              omml_parameter(parameter_one, display_style, tag_name: "e",
+                                                           namespace: "m", options: options),
             ],
           )
           [acc_tag]

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

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-
 module Plurimath
   module Math
     module Function
       class Oint < TernaryFunction
         attr_accessor :options
+
         FUNCTION = {
           name: "contour integral",
           first_value: "subscript",
@@ -21,18 +21,30 @@ module Plurimath
         end
 
         def ==(object)
-          super(object) && object.options == options
+          super && object.options == options
         end
 
         def to_asciimath(options:)
-          first_value = "_#{wrapped(parameter_one, options: options)}" if parameter_one
-          second_value = "^#{wrapped(parameter_two, options: options)}" if parameter_two
+          if parameter_one
+            first_value = "_#{wrapped(parameter_one,
+                                      options: options)}"
+          end
+          if parameter_two
+            second_value = "^#{wrapped(parameter_two,
+                                       options: options)}"
+          end
           "oint#{first_value}#{second_value} #{parameter_three&.to_asciimath(options: options)}".strip
         end
 
         def to_latex(options:)
-          first_value = "_#{latex_wrapped(parameter_one, options: options)}" if parameter_one
-          second_value = "^#{latex_wrapped(parameter_two, options: options)}" if parameter_two
+          if parameter_one
+            first_value = "_#{latex_wrapped(parameter_one,
+                                            options: options)}"
+          end
+          if parameter_two
+            second_value = "^#{latex_wrapped(parameter_two,
+                                             options: options)}"
+          end
           "\\#{class_name}#{first_value}#{second_value} #{parameter_three&.to_latex(options: options)}".strip
         end
 
@@ -51,8 +63,10 @@ module Plurimath
             oint_tag,
             [
               mo_tag,
-              parameter_one&.to_mathml_without_math_tag(intent, options: options),
-              parameter_two&.to_mathml_without_math_tag(intent, options: options),
+              parameter_one&.to_mathml_without_math_tag(intent,
+                                                        options: options),
+              parameter_two&.to_mathml_without_math_tag(intent,
+                                                        options: options),
             ],
           )
           return ternary_intentify(oint_tag, intent) unless parameter_three
@@ -62,7 +76,10 @@ module Plurimath
               ox_element("mrow"),
               [
                 oint_tag,
-                wrap_mrow(parameter_three&.to_mathml_without_math_tag(intent, options: options), intent),
+                wrap_mrow(
+                  parameter_three&.to_mathml_without_math_tag(intent,
+                                                              options: options), intent
+                ),
               ],
             ),
             intent,
@@ -75,10 +92,14 @@ module Plurimath
             Utility.update_nodes(
               nary,
               [
-                narypr((hide_function_name ? "" : "∮"), function_type: "subSup"),
-                omml_parameter(parameter_one, display_style, tag_name: "sub", options: options),
-                omml_parameter(parameter_two, display_style, tag_name: "sup", options: options),
-                omml_parameter(parameter_three, display_style, tag_name: "e", options: options),
+                narypr((hide_function_name ? "" : "∮"),
+                       function_type: "subSup"),
+                omml_parameter(parameter_one, display_style, tag_name: "sub",
+                                                             options: options),
+                omml_parameter(parameter_two, display_style, tag_name: "sup",
+                                                             options: options),
+                omml_parameter(parameter_three, display_style, tag_name: "e",
+                                                               options: options),
               ],
             )
             [nary]
@@ -91,16 +112,25 @@ module Plurimath
         end
 
         def to_unicodemath(options:)
-          first_value = "_#{unicodemath_parens(parameter_one, options: options)}" if parameter_one
-          second_value = "^#{unicodemath_parens(parameter_two, options: options)}" if parameter_two
+          if parameter_one
+            first_value = "_#{unicodemath_parens(parameter_one,
+                                                 options: options)}"
+          end
+          if parameter_two
+            second_value = "^#{unicodemath_parens(parameter_two,
+                                                  options: options)}"
+          end
           mask = self.options&.dig(:mask) if self.options&.key?(:mask)
-          "∮#{mask}#{first_value}#{second_value}#{naryand_value(parameter_three, options: options)}"
+          "∮#{mask}#{first_value}#{second_value}#{naryand_value(
+            parameter_three, options: options
+          )}"
         end
 
         def line_breaking(obj)
           parameter_one&.line_breaking(obj)
           if obj.value_exist?
-            oint = self.class.new(Utility.filter_values(obj.value), parameter_two, parameter_three)
+            oint = self.class.new(Utility.filter_values(obj.value),
+                                  parameter_two, parameter_three)
             oint.hide_function_name = true
             obj.update(oint)
             self.parameter_two = nil
@@ -119,7 +149,7 @@ module Plurimath
         end
 
         def intent_names
-          { name: ":contour integral"}
+          { name: ":contour integral" }
         end
 
         private

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

@@ -1,11 +1,9 @@
 # frozen_string_literal: true
 
-
 module Plurimath
   module Math
     module Function
       class Over < BinaryFunction
-
         FUNCTION = {
           name: "over",
           first_value: "numerator",
@@ -40,23 +38,32 @@ module Plurimath
             f_element,
             [
               fpr_element << Utility.pr_element("ctrl", true, namespace: "m"),
-              omml_parameter(parameter_one, display_style, tag_name: "num", options: options),
-              omml_parameter(parameter_two, display_style, tag_name: "den", options: options),
+              omml_parameter(parameter_one, display_style, tag_name: "num",
+                                                           options: options),
+              omml_parameter(parameter_two, display_style, tag_name: "den",
+                                                           options: options),
             ],
           )
           [f_element]
         end
 
         def to_unicodemath(options:)
-          first_value = unicodemath_parens(parameter_one, options: options) if parameter_one
-          second_value = unicodemath_parens(parameter_two, options: options) if parameter_two
+          if parameter_one
+            first_value = unicodemath_parens(parameter_one,
+                                             options: options)
+          end
+          if parameter_two
+            second_value = unicodemath_parens(parameter_two,
+                                              options: options)
+          end
           "#{first_value}/#{second_value}"
         end
 
         def line_breaking(obj)
           parameter_one&.line_breaking(obj)
           if obj.value_exist?
-            obj.update(self.class.new(Utility.filter_values(obj.value), parameter_two))
+            obj.update(self.class.new(Utility.filter_values(obj.value),
+                                      parameter_two))
             self.parameter_two = nil
             self.hide_function_name = true
             return