plurimath 0.10.2 → 0.10.3

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

@@ -41,7 +41,9 @@ module Plurimath
           return parentheless_table(options: options) if SIMPLE_TABLES.include?(class_name)
 
           parenthesis = Asciimath::Constants::TABLE_PARENTHESIS
-          first_value = value&.map { |val| val&.to_asciimath(options: options) }&.join(", ")
+          first_value = value&.map do |val|
+            val&.to_asciimath(options: options)
+          end&.join(", ")
           lparen = open_paren.nil? ? "[" : open_paren.to_asciimath(options: options)
           rparen = close_paren.nil? ? parenthesis[lparen.to_sym] : close_paren.to_asciimath(options: options)
           "#{lparen}#{first_value}#{rparen}"
@@ -52,16 +54,23 @@ module Plurimath
           table_tag["intent"] = ":matrix(#{value.length},#{td_count})" if intent
           Utility.update_nodes(
             table_tag,
-            value&.map { |object| object&.to_mathml_without_math_tag(intent, options: options) },
+            value&.map do |object|
+              object&.to_mathml_without_math_tag(intent, options: options)
+            end,
           )
           return norm_table(table_tag) if open_paren.is_a?(Math::Symbols::Paren::Norm)
 
-          if mathml_paren_present?(open_paren, intent, options: options) || mathml_paren_present?(close_paren, intent, options: options)
-            first_paren = mo_element(mathml_parenthesis(open_paren, intent, options: options))
-            second_paren = mo_element(mathml_parenthesis(close_paren, intent, options: options))
+          if mathml_paren_present?(open_paren, intent,
+                                   options: options) || mathml_paren_present?(close_paren, intent,
+                                                                              options: options)
+            first_paren = mo_element(mathml_parenthesis(open_paren, intent,
+                                                        options: options))
+            second_paren = mo_element(mathml_parenthesis(close_paren, intent,
+                                                         options: options))
             attributes = { intent: ":fenced" } if intent
             mrow = ox_element("mrow", attributes: attributes)
-            return Utility.update_nodes(mrow, [first_paren, table_tag, second_paren])
+            return Utility.update_nodes(mrow,
+                                        [first_paren, table_tag, second_paren])
           end
 
           table_tag
@@ -73,8 +82,8 @@ module Plurimath
           separator = "{#{table_attribute(:latex)}}" if environment&.include?("array")
           left_paren = open_paren&.to_latex(options: options) || "."
           right_paren = close_paren&.to_latex(options: options) || "."
-          left = "\\left #{left_paren.delete_prefix("\\left")}\\begin{matrix}"
-          right = "\\end{matrix}\\right #{right_paren.delete_prefix("\\right")}"
+          left = "\\left #{left_paren.delete_prefix('\\left')}\\begin{matrix}"
+          right = "\\end{matrix}\\right #{right_paren.delete_prefix('\\right')}"
           "#{left}#{separator}#{latex_content(options: options)}#{right}"
         end
 
@@ -93,7 +102,9 @@ module Plurimath
         end
 
         def to_unicodemath(options:)
-          table_values = value&.map { |val| val&.to_unicodemath(options: options) }&.join("@")
+          table_values = value&.map do |val|
+            val&.to_unicodemath(options: options)
+          end&.join("@")
           if unicodemath_table_class?
             "#{unicodemath_class_name}(#{table_values})"
           else
@@ -101,38 +112,48 @@ module Plurimath
           end
         end
 
-        def to_asciimath_math_zone(spacing, last = false, indent = true, options:)
+        def to_asciimath_math_zone(spacing, last = false, indent = true,
+options:)
           [
             "#{spacing}\"table\" function apply\n",
-            Formula.new(value).to_asciimath_math_zone(gsub_spacing(spacing, last), last, indent, options: options),
+            Formula.new(value).to_asciimath_math_zone(
+              gsub_spacing(spacing, last), last, indent, options: options
+            ),
           ]
         end
 
         def to_latex_math_zone(spacing, last = false, indent = true, options:)
           [
             "#{spacing}\"table\" function apply\n",
-            Formula.new(value).to_latex_math_zone(gsub_spacing(spacing, last), last, indent, options: options),
+            Formula.new(value).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}\"table\" function apply\n",
-            Formula.new(value).to_mathml_math_zone(gsub_spacing(spacing, last), last, indent, options: options),
+            Formula.new(value).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}\"table\" function apply\n",
-            Formula.new(value).to_omml_math_zone(gsub_spacing(spacing, last), last, indent, display_style: display_style, options: options),
+            Formula.new(value).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}\"table\" function apply\n",
-            Formula.new(value).to_unicodemath_math_zone(gsub_spacing(spacing, last), last, indent, options: options),
+            Formula.new(value).to_unicodemath_math_zone(
+              gsub_spacing(spacing, last), last, indent, options: options
+            ),
           ]
         end
 
@@ -182,11 +203,12 @@ module Plurimath
           return "" unless field
 
           if field&.class_name == "symbol"
-            paren = field&.to_mathml_without_math_tag(intent, options: options)&.nodes&.first
+            paren = field&.to_mathml_without_math_tag(intent,
+                                                      options: options)&.nodes&.first
             return invisible_paren?(paren) ? "" : paren.to_s
           end
 
-          paren = field&.respond_to?(:encoded) ? field&.encoded : field&.paren_value
+          paren = field.respond_to?(:encoded) ? field&.encoded : field&.paren_value
           invisible_paren?(paren) ? "" : paren
         end
 
@@ -205,7 +227,12 @@ module Plurimath
           columns_array = []
           value.first.parameter_one.each_with_index do |td, i|
             if td.parameter_one.find { |obj| Utility.symbol_value(obj, "|") }
-              columns_array.empty? ? columns_array = ["solid"] : columns_array[i - 1] = "solid"
+              if columns_array.empty?
+                columns_array = ["solid"]
+              else
+                columns_array[i - 1] =
+                  "solid"
+              end
             else
               columns_array << "none"
             end
@@ -215,7 +242,10 @@ module Plurimath
 
         def mathml_attrs(column_strings)
           args = options&.dup&.reject { |arg| arg.to_s == "asterisk" }
-          args[:columnlines] = column_strings.join(" ") if column_strings.include?("solid")
+          if column_strings.include?("solid")
+            args[:columnlines] =
+              column_strings.join(" ")
+          end
           args[:columnalign] = "left" if close_paren.is_a?(Math::Symbols::Paren::CloseParen)
           args
         end
@@ -258,7 +288,9 @@ module Plurimath
           eqarrpr  = Utility.ox_element("eqArrPr", namespace: "m")
           eqarrpr  << Utility.pr_element("ctrl", true, namespace: "m")
           eqarr    << eqarrpr
-          tr_value = value.map { |object| object.to_omml_without_math_tag(display_style, options: options) }.flatten
+          tr_value = value.map do |object|
+            object.to_omml_without_math_tag(display_style, options: options)
+          end.flatten
           Utility.update_nodes(eqarr, tr_value.compact)
           [eqarr]
         end
@@ -287,7 +319,9 @@ module Plurimath
           mcs << mc
           mpr << mcs
           mpr << ctrlpr
-          mm_value = value&.map { |object| object.to_omml_without_math_tag(display_style, options: options) }
+          mm_value = value&.map do |object|
+            object.to_omml_without_math_tag(display_style, options: options)
+          end
           Utility.update_nodes(
             mm,
             mm_value.insert(0, mpr).flatten,
@@ -317,8 +351,9 @@ module Plurimath
         end
 
         def mdpr_node
-          sepchr = Utility.ox_element("sepChr", attributes: { "m:val": "" }, namespace: "m")
-          mgrow  = Utility.ox_element("grow", namespace: "m")
+          sepchr = Utility.ox_element("sepChr", attributes: { "m:val": "" },
+                                                namespace: "m")
+          mgrow = Utility.ox_element("grow", namespace: "m")
           mdpr = Utility.ox_element("dPr", namespace: "m")
           Utility.update_nodes(mdpr, [begchr, endchr, sepchr, mgrow])
         end
@@ -326,13 +361,15 @@ module Plurimath
         def begchr
           return unless open_paren
 
-          Utility.ox_element("begChr", attributes: { "m:val": paren(open_paren) }, namespace: "m")
+          Utility.ox_element("begChr",
+                             attributes: { "m:val": paren(open_paren) }, namespace: "m")
         end
 
         def endchr
           return unless close_paren
 
-          Utility.ox_element("endChr", attributes: { "m:val": paren(close_paren) }, namespace: "m")
+          Utility.ox_element("endChr",
+                             attributes: { "m:val": paren(close_paren) }, namespace: "m")
         end
 
         def paren(parenthesis)
@@ -340,7 +377,9 @@ module Plurimath
         end
 
         def parentheless_table(options:)
-          "{:#{value.map { |val| val&.to_asciimath(options: options) }&.join(", ")}:}"
+          "{:#{value.map do |val|
+            val&.to_asciimath(options: options)
+          end&.join(', ')}:}"
         end
 
         def single_table?
@@ -365,8 +404,8 @@ module Plurimath
         end
 
         def unicodemath_table_class?
-          return unless class_name == "table"
-          return if open_paren.nil? && close_paren.nil?
+          return false unless class_name == "table"
+          return false if open_paren.nil? && close_paren.nil?
 
           (!open_paren.nil? && !close_paren.nil?) ||
             Utility::PARENTHESIS[unicodemath_field_value(open_paren)] == close_paren ||
@@ -374,8 +413,9 @@ module Plurimath
         end
 
         def unicodemath_class_name
-          return matrices_functions(:Vmatrix) if class_name == "vmatrix" && open_paren&.class_name&.is_a?(Math::Symbols::Paren::Norm)
-          return matrices_functions(:vmatrix) if [open_paren, close_paren].all?(Math::Symbols::Paren::Vert)
+          return matrices_functions(:Vmatrix) if class_name == "vmatrix" && open_paren&.class_name.is_a?(Math::Symbols::Paren::Norm)
+          return matrices_functions(:vmatrix) if [open_paren,
+                                                  close_paren].all?(Math::Symbols::Paren::Vert)
           return matrices_functions(:matrix) if class_name == "Bmatrix" && open_paren == Math::Symbols::Paren::Lcurly
           return unless unicodemath_table_class?
 
@@ -388,9 +428,10 @@ module Plurimath
         end
 
         def mathml_paren_present?(paren, intent, options:)
-          return unless paren || paren&.class_name == "symbol"
+          return false unless paren || paren&.class_name == "symbol"
 
-          !paren&.to_mathml_without_math_tag(intent, options: options)&.nodes&.first&.empty?
+          !paren&.to_mathml_without_math_tag(intent,
+                                             options: options)&.nodes&.first&.empty?
         end
 
         def td_count

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

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-
 module Plurimath
   module Math
     module Function

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

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-
 module Plurimath
   module Math
     module Function

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

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-
 module Plurimath
   module Math
     module Function
@@ -22,7 +21,9 @@ module Plurimath
           td_attribute = parameter_two if parameter_two&.any?
           Utility.update_nodes(
             ox_element("mtd", attributes: td_attribute),
-            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
 
@@ -33,74 +34,97 @@ module Plurimath
         end
 
         def to_html(options:)
-          first_value = parameter_one.map { |val| val.to_html(options: options) }.join
+          first_value = parameter_one.map do |val|
+            val.to_html(options: options)
+          end.join
           "<td>#{first_value}</td>"
         end
 
         def to_omml_without_math_tag(display_style, options:)
           me = Utility.ox_element("e", namespace: "m")
-          return [me] if parameter_one&.empty?
+          return [me] if parameter_one && parameter_one.empty?
 
-          Utility.update_nodes(me, omml_content(display_style, options: options))
+          Utility.update_nodes(me,
+                               omml_content(display_style, options: options))
           [me]
         end
 
         def to_unicodemath(options:)
-          parameter_one&.map { |val| val&.to_unicodemath(options: options) }&.join
+          parameter_one&.map do |val|
+            val&.to_unicodemath(options: options)
+          end&.join
         end
 
         def to_asciimath_math_zone(spacing, last = false, _, options:)
           [
             "#{spacing}\"td\" function apply\n",
-            Formula.new(parameter_one).to_asciimath_math_zone(gsub_spacing(spacing, last), last, options: options),
+            Formula.new(parameter_one).to_asciimath_math_zone(
+              gsub_spacing(spacing, last), last, options: options
+            ),
           ]
         end
 
         def to_latex_math_zone(spacing, last = false, indent = true, options:)
           [
             "#{spacing}\"td\" 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}\"td\" 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}\"td\" 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, _, options:)
           [
             "#{spacing}\"td\" function apply\n",
-            Formula.new(parameter_one).to_unicodemath_math_zone(gsub_spacing(spacing, last), last, options: options),
+            Formula.new(parameter_one).to_unicodemath_math_zone(
+              gsub_spacing(spacing, last), last, options: options
+            ),
           ]
         end
 
         def to_unicodemath_math_zone(spacing, last = false, _, options:)
           [
             "#{spacing}\"td\" function apply\n",
-            Formula.new(parameter_one).to_unicodemath_math_zone(gsub_spacing(spacing, last), last, options: options),
+            Formula.new(parameter_one).to_unicodemath_math_zone(
+              gsub_spacing(spacing, last), last, options: options
+            ),
           ]
         end
 
         def omml_content(display_style, options:)
-          parameter_one&.map { |val| val.insert_t_tag(display_style, options: options) }
+          parameter_one&.map do |val|
+            val.insert_t_tag(display_style, options: options)
+          end
         end
 
-        def line_breaking(obj)
+        def line_breaking(_obj)
           sliced_value = result(Array(parameter_one))
           return unless sliced_value.length > 1
 
           sliced_result = sliced_value.first.last.omml_line_break(sliced_value)
-          table = Table.new(sliced_result.map { |res| Tr.new(Array(Td.new(Array(res)))) })
+          table = Table.new(sliced_result.map do |res|
+            Tr.new(Array(Td.new(Array(res))))
+          end)
           self.parameter_one = [table]
         end
 

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

@@ -4,7 +4,8 @@ module Plurimath
   module Math
     module Function
       class TernaryFunction < Core
-        attr_accessor :parameter_one, :parameter_two, :parameter_three, :hide_function_name
+        attr_accessor :parameter_one, :parameter_two, :parameter_three,
+                      :hide_function_name
 
         def initialize(parameter_one = nil,
                        parameter_two = nil,
@@ -23,9 +24,18 @@ module Plurimath
         end
 
         def to_asciimath(options:)
-          first_value = first_field_wrap(parameter_one, options: options) if parameter_one
-          second_value = "_#{wrapped(parameter_two, options: options)}" if parameter_two
-          third_value = "^#{wrapped(parameter_three, options: options)}" if parameter_three
+          if parameter_one
+            first_value = first_field_wrap(parameter_one,
+                                           options: options)
+          end
+          if parameter_two
+            second_value = "_#{wrapped(parameter_two,
+                                       options: options)}"
+          end
+          if parameter_three
+            third_value = "^#{wrapped(parameter_three,
+                                      options: options)}"
+          end
           "#{first_value}#{second_value}#{third_value}"
         end
 
@@ -67,9 +77,15 @@ module Plurimath
           parameters = self.class::FUNCTION
           new_spacing = gsub_spacing(spacing, last)
           new_arr = ["#{spacing}\"#{to_asciimath(options: options)}\" #{parameters[:name]}\n"]
-          ascii_fields_to_print(parameter_one, { spacing: new_spacing, field_name: parameters[:first_value], additional_space: "|  |_ ", array: new_arr, options: options })
-          ascii_fields_to_print(parameter_two, { spacing: new_spacing, field_name: parameters[:second_value], additional_space: "  |_ ", array: new_arr, options: options })
-          ascii_fields_to_print(parameter_three, { spacing: new_spacing, field_name: parameters[:third_value], additional_space: "   |_ ", array: new_arr, options: options })
+          ascii_fields_to_print(parameter_one,
+                                { spacing: new_spacing, field_name: parameters[:first_value],
+                                  additional_space: "|  |_ ", array: new_arr, options: options })
+          ascii_fields_to_print(parameter_two,
+                                { spacing: new_spacing, field_name: parameters[:second_value],
+                                  additional_space: "  |_ ", array: new_arr, options: options })
+          ascii_fields_to_print(parameter_three,
+                                { spacing: new_spacing, field_name: parameters[:third_value],
+                                  additional_space: "   |_ ", array: new_arr, options: options })
           new_arr
         end
 
@@ -77,29 +93,50 @@ module Plurimath
           parameters = self.class::FUNCTION
           new_spacing = gsub_spacing(spacing, last)
           new_arr = ["#{spacing}\"#{to_latex(options: options)}\" #{parameters[:name]}\n"]
-          latex_fields_to_print(parameter_one, { spacing: new_spacing, field_name: parameters[:first_value], additional_space: "|  |_ ", array: new_arr, options: options })
-          latex_fields_to_print(parameter_two, { spacing: new_spacing, field_name: parameters[:second_value], additional_space: "  |_ ", array: new_arr, options: options })
-          latex_fields_to_print(parameter_three, { spacing: new_spacing, field_name: parameters[:third_value], additional_space: "   |_ ", array: new_arr, options: options })
+          latex_fields_to_print(parameter_one,
+                                { spacing: new_spacing, field_name: parameters[:first_value],
+                                  additional_space: "|  |_ ", array: new_arr, options: options })
+          latex_fields_to_print(parameter_two,
+                                { spacing: new_spacing, field_name: parameters[:second_value],
+                                  additional_space: "  |_ ", array: new_arr, options: options })
+          latex_fields_to_print(parameter_three,
+                                { spacing: new_spacing, field_name: parameters[:third_value],
+                                  additional_space: "   |_ ", array: new_arr, options: options })
           new_arr
         end
 
         def to_mathml_math_zone(spacing, last = false, _, options:)
           parameters = self.class::FUNCTION
           new_spacing = gsub_spacing(spacing, last)
-          new_arr = ["#{spacing}\"#{dump_mathml(self, options: options)}\" #{parameters[:name]}\n"]
-          mathml_fields_to_print(parameter_one, { spacing: new_spacing, field_name: parameters[:first_value], additional_space: "|  |_ ", array: new_arr, options: options })
-          mathml_fields_to_print(parameter_two, { spacing: new_spacing, field_name: parameters[:second_value], additional_space: "  |_ ", array: new_arr, options: options })
-          mathml_fields_to_print(parameter_three, { spacing: new_spacing, field_name: parameters[:third_value], additional_space: "   |_ ", array: new_arr, options: options })
+          new_arr = ["#{spacing}\"#{dump_mathml(self,
+                                                options: options)}\" #{parameters[:name]}\n"]
+          mathml_fields_to_print(parameter_one,
+                                 { spacing: new_spacing, field_name: parameters[:first_value],
+                                   additional_space: "|  |_ ", array: new_arr, options: options })
+          mathml_fields_to_print(parameter_two,
+                                 { spacing: new_spacing, field_name: parameters[:second_value],
+                                   additional_space: "  |_ ", array: new_arr, options: options })
+          mathml_fields_to_print(parameter_three,
+                                 { spacing: new_spacing, field_name: parameters[:third_value],
+                                   additional_space: "   |_ ", array: new_arr, options: options })
           new_arr
         end
 
-        def to_omml_math_zone(spacing, last = false, _, display_style:, options:)
+        def to_omml_math_zone(spacing, last = false, _, display_style:,
+options:)
           parameters = self.class::FUNCTION
           new_spacing = gsub_spacing(spacing, last)
-          new_arr = ["#{spacing}\"#{dump_omml(self, display_style, options: options)}\" #{parameters[:name]}\n"]
-          omml_fields_to_print(parameter_one, { spacing: new_spacing, field_name: parameters[:first_value], additional_space: "|  |_ ", array: new_arr, display_style: display_style, options: options })
-          omml_fields_to_print(parameter_two, { spacing: new_spacing, field_name: parameters[:second_value], additional_space: "  |_ ", array: new_arr, display_style: display_style, options: options })
-          omml_fields_to_print(parameter_three, { spacing: new_spacing, field_name: parameters[:third_value], additional_space: "   |_ ", array: new_arr, display_style: display_style, options: options })
+          new_arr = ["#{spacing}\"#{dump_omml(self, display_style,
+                                              options: options)}\" #{parameters[:name]}\n"]
+          omml_fields_to_print(parameter_one,
+                               { spacing: new_spacing, field_name: parameters[:first_value],
+                                 additional_space: "|  |_ ", array: new_arr, display_style: display_style, options: options })
+          omml_fields_to_print(parameter_two,
+                               { spacing: new_spacing, field_name: parameters[:second_value],
+                                 additional_space: "  |_ ", array: new_arr, display_style: display_style, options: options })
+          omml_fields_to_print(parameter_three,
+                               { spacing: new_spacing, field_name: parameters[:third_value],
+                                 additional_space: "   |_ ", array: new_arr, display_style: display_style, options: options })
           new_arr
         end
 
@@ -107,9 +144,15 @@ module Plurimath
           parameters = self.class::FUNCTION
           new_spacing = gsub_spacing(spacing, last)
           new_arr = ["#{spacing}\"#{to_unicodemath(options: options)}\" #{parameters[:name]}\n"]
-          unicodemath_fields_to_print(parameter_one, { spacing: new_spacing, field_name: parameters[:first_value], additional_space: "|  |_ ", array: new_arr, options: options })
-          unicodemath_fields_to_print(parameter_two, { spacing: new_spacing, field_name: parameters[:second_value], additional_space: "  |_ ", array: new_arr, options: options })
-          unicodemath_fields_to_print(parameter_three, { spacing: new_spacing, field_name: parameters[:third_value], additional_space: "   |_ ", array: new_arr, options: options })
+          unicodemath_fields_to_print(parameter_one,
+                                      { spacing: new_spacing, field_name: parameters[:first_value],
+                                        additional_space: "|  |_ ", array: new_arr, options: options })
+          unicodemath_fields_to_print(parameter_two,
+                                      { spacing: new_spacing, field_name: parameters[:second_value],
+                                        additional_space: "  |_ ", array: new_arr, options: options })
+          unicodemath_fields_to_print(parameter_three,
+                                      { spacing: new_spacing, field_name: parameters[:third_value],
+                                        additional_space: "   |_ ", array: new_arr, options: options })
           new_arr
         end
 
@@ -124,16 +167,22 @@ module Plurimath
           end
         end
 
-        def wrapped(field, type: "ascii", options:)
+        def wrapped(field, options:, type: "ascii")
           return "" unless field
 
           type == "ascii" ? "(#{field.to_asciimath(options: options)})" : "{#{field.to_latex(options: options)}}"
         end
 
-        def first_field_wrap(field, type: "ascii", options:)
+        def first_field_wrap(field, options:, type: "ascii")
           return "" unless field
 
-          type == "ascii" ? ascii_wrap(field, options: options) : latex_wrap(field, options: options)
+          if type == "ascii"
+            ascii_wrap(field,
+                       options: options)
+          else
+            latex_wrap(field,
+                       options: options)
+          end
         end
 
         def ascii_wrap(field, options:)
@@ -165,10 +214,14 @@ module Plurimath
           limloc_arg  = { "m:val": function_type }
           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")
-          suphide_tag = Utility.ox_element("supHide", attributes: suphide_arg, namespace: "m")
+          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")
+          suphide_tag = Utility.ox_element("supHide", attributes: suphide_arg,
+                                                      namespace: "m")
           nary_pr_tag = Utility.ox_element("naryPr", namespace: "m")
           Utility.update_nodes(
             nary_pr_tag,
@@ -191,9 +244,14 @@ module Plurimath
           # Build Overset from source argument positions, not OMML child names,
           # so shared under/over functions keep the same format-neutral model.
           overset = Overset.new(parameter_one, parameter_three)
-          return overset.to_omml_without_math_tag(display_style, options: options) unless parameter_two
+          unless parameter_two
+            return overset.to_omml_without_math_tag(display_style,
+                                                    options: options)
+          end
 
-          Underset.new(overset, parameter_two)&.to_omml_without_math_tag(display_style, options: options)
+          Underset.new(overset, parameter_two)&.to_omml_without_math_tag(
+            display_style, options: options
+          )
         end
 
         def naryand_value(field, options:)

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

@@ -4,8 +4,7 @@ module Plurimath
   module Math
     module Function
       class Text < UnaryFunction
-
-        PARSER_REGEX = %r{unicode\[:(?<unicode>\w{1,})\]}.freeze
+        PARSER_REGEX = %r{unicode\[:(?<unicode>\w{1,})\]}
 
         def initialize(parameter_one = "", lang: nil)
           super(parameter_one)
@@ -14,14 +13,14 @@ module Plurimath
 
         def ==(object)
           object.class == self.class &&
-            object.parameter_one == self.parameter_one
+            object.parameter_one == parameter_one
         end
 
         def to_asciimath(**)
           "\"#{parse_text('asciimath') || parameter_one}\""
         end
 
-        def to_mathml_without_math_tag(intent, **)
+        def to_mathml_without_math_tag(_intent, **)
           text = ox_element("mtext")
           return text unless parameter_one
 
@@ -46,7 +45,7 @@ module Plurimath
         def to_unicodemath(**)
           return unless value
 
-          value&.start_with?("\\") ? value : "\"#{(Utility.html_entity_to_unicode(value))}\""
+          value&.start_with?("\\") ? value : "\"#{Utility.html_entity_to_unicode(value)}\""
         end
 
         def insert_t_tag(display_style, options:)
@@ -80,7 +79,8 @@ module Plurimath
         end
 
         def to_omml_math_zone(spacing, _, _, display_style:, options:)
-          "#{spacing}\"#{dump_omml(self, display_style, options: options)}\" text\n"
+          "#{spacing}\"#{dump_omml(self, display_style,
+                                   options: options)}\" text\n"
         end
 
         def to_unicodemath_math_zone(spacing, _, _, options:)
@@ -113,7 +113,7 @@ module Plurimath
 
         def parse_text(lang)
           html_value = first_value(lang).dup
-          html_value = html_value&.gsub(PARSER_REGEX) do |_text|
+          html_value&.gsub(PARSER_REGEX) do |_text|
             last_match = Regexp.last_match
             case lang
             when "mathml", "html", "omml"
@@ -122,7 +122,6 @@ module Plurimath
               last_match[:unicode]
             end
           end
-          html_value
         end
 
         def first_value(lang)