plurimath 0.8.16 → 0.8.18

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

@@ -1,11 +1,14 @@
 # frozen_string_literal: true
 
 require_relative "ternary_function"
+require_relative "../../mathml/utility"
 
 module Plurimath
   module Math
     module Function
       class Fenced < TernaryFunction
+        include Mathml::Utility
+
         attr_accessor :options
 
         def initialize(
@@ -39,6 +42,7 @@ module Plurimath
             intent,
             func_name: :interval_fence,
             intent_name: intent_value(mrow_value, options: options),
+            options: intent_names,
           )
         end
 
@@ -145,8 +149,231 @@ module Plurimath
           "#{parameter_one.to_unicodemath(options: options)}#{fenced_value}#{parameter_three.to_unicodemath(options: options)}"
         end
 
+        def intent_names
+          {
+            open_closed_interval: "open-closed-interval",
+            closed_open_interval: "closed-open-interval",
+            binomial_coefficient: "binomial-coefficient",
+            closed_interval: "closed-interval",
+            open_interval: "open-interval",
+            fenced: ":fenced",
+          }
+        end
+
+        def separators=(value)
+          return if value.nil?
+
+          @options[:separators] = value
+        end
+
+        def content=(value)
+          if parens_nil?
+            @parameter_one = Math::Symbols::Paren::Lround.new
+            @parameter_three = Math::Symbols::Paren::Rround.new
+          end
+        end
+
+        def open=(value)
+          return unless value
+
+          @parameter_one = validate_symbols(value)
+        end
+
+        def close=(value)
+          return unless value
+
+          @parameter_three = validate_symbols(value)
+        end
+
+        def element_order=(value)
+          @parameter_two = validated_order(value)
+        end
+
+        def mi_value=(value)
+          return if value.nil? || value.empty?
+
+          update(
+            replace_order_with_value(
+              @parameter_two,
+              Array(validate_symbols(value)),
+              "mi"
+            )
+          )
+        end
+
+        def mn_value=(value)
+          return if value.nil? || value.empty?
+
+          update(
+            replace_order_with_value(
+              @parameter_two,
+              Array(validate_symbols(value)),
+              "mn"
+            )
+          )
+        end
+
+        def mtext_value=(value)
+          return if value.nil? || value.empty?
+
+          update(
+            replace_order_with_value(
+              @parameter_two,
+              Array(validate_symbols(value)),
+              "mtext"
+            )
+          )
+        end
+
+        def mo_value=(value)
+          return if value.nil? || value.empty?
+
+          update(
+            replace_order_with_value(
+              @parameter_two,
+              Array(validate_symbols(value)),
+              "mo"
+            )
+          )
+        end
+
+        def mstyle_value=(value)
+          return if value.empty?
+
+          update(
+            replace_order_with_value(
+              @parameter_two,
+              Array(value),
+              "mstyle"
+            )
+          )
+        end
+
+        def munderover_value=(value)
+          update_temp_order(value, "munderover")
+        end
+
+        def msub_value=(value)
+          update_temp_order(value, "msub")
+        end
+
+        def msup_value=(value)
+          update_temp_order(value, "msup")
+        end
+
+        def mover_value=(value)
+          update_temp_order(value, "mover")
+        end
+
+        def munder_value=(value)
+          update_temp_order(value, "munder")
+        end
+
+        def msubsup_value=(value)
+          update_temp_order(value, "msubsup")
+        end
+
+        def mfrac_value=(value)
+          update_temp_order(value, "mfrac")
+        end
+
+        def msqrt_value=(value)
+          update_temp_order(value, "msqrt")
+        end
+
+        def mfenced_value=(value)
+          update_temp_order(value, "mfenced")
+        end
+
+        def mtable_value=(value)
+          return if value.nil? || value.empty?
+
+          update(
+            replace_order_with_value(
+              Array(@parameter_two),
+              update_temp_mathml_values(value),
+              "mtable"
+            )
+          )
+        end
+
+        def mrow_value=(value)
+          return if value.nil? || value.empty?
+
+          update(
+            replace_order_with_value(
+              Array(@parameter_two),
+              update_temp_mathml_values(
+                Array(filter_values(value, array_to_instance: true))
+              ),
+              "mrow"
+            )
+          )
+        end
+
+        def mspace_value=(value)
+          return if value.nil? || value.empty?
+
+          if value.first.linebreak
+            linebreak = Math::Function::Linebreak.new(
+              nil,
+              { linebreak: value.first.linebreak }
+            )
+
+            update(
+              replace_order_with_value(
+                Array(@parameter_two),
+                [linebreak],
+                "mspace"
+              )
+            )
+          else
+            @parameter_two&.delete("mspace")
+          end
+        end
+
+        def mpadded_value=(value)
+          update_temp_order(value, "mpadded")
+        end
+
+        def mfraction_value=(value)
+          update_temp_order(value, "mfraction")
+        end
+
+        def mmultiscripts_value=(value)
+          update_temp_order(value, "mmultiscripts")
+        end
+
+        def mphantom_value=(value)
+          update_temp_order(value, "mphantom")
+        end
+
         protected
 
+        def update_temp_order(value, order_name)
+          return if value.nil? || value.empty?
+
+          update(
+            replace_order_with_value(
+              Array(@parameter_two),
+              update_temp_mathml_values(value),
+              order_name
+            )
+          )
+        end
+
+        def remove_order(order)
+          @parameter_two.delete_if { |val| val.is_a?(String) && val == order }
+        end
+
+        def insert(values)
+          update(Array(@parameter_two) + values)
+        end
+
+        def update(object)
+          @parameter_two = Array(object)
+        end
+
         def open_paren(dpr, options:)
           first_value = symbol_or_paren(parameter_one, lang: :omml, options: options)
           return dpr if first_value.nil?
@@ -253,11 +480,11 @@ module Plurimath
         end
 
         def intent_value(value, options:)
-          return "binomial-coefficient" if binomial_coefficient?(value)
+          return :binomial_coefficient if binomial_coefficient?(value)
 
           open_paren = symbol_or_paren(parameter_one, lang: :latex, options: options)
           close_paren = symbol_or_paren(parameter_three, lang: :latex, options: options)
-          return "fenced" unless interval_intent?(value, open_paren, close_paren)
+          return :fenced unless interval_intent?(value, open_paren, close_paren)
 
           interval_intent(value, open_paren, close_paren)
         end
@@ -270,15 +497,15 @@ module Plurimath
         def interval_intent(value, open_paren, close_paren)
           case open_paren
           when "("
-            'open-closed-interval' if close_paren == ']'
+            :open_closed_interval if close_paren == ']'
           when "["
-            return 'closed-interval' if close_paren == ']'
+            return :closed_interval if close_paren == ']'
 
-            'closed-open-interval' if (close_paren == '[' || close_paren == ')')
+            :closed_open_interval if (close_paren == '[' || close_paren == ')')
           when "]"
-            return 'open-closed-interval' if close_paren == ']'
+            return :open_closed_interval if close_paren == ']'
 
-            'open-interval' if close_paren == '['
+            :open_interval if close_paren == '['
           end
         end
 
@@ -347,6 +574,10 @@ module Plurimath
           node["intent"]&.start_with?(":partial-derivative") &&
             !node.locate("*/@arg").include?("f")
         end
+
+        def parens_nil?
+          @parameter_one.nil? && @parameter_three.nil?
+        end
       end
     end
   end

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

@@ -1,12 +1,16 @@
 # frozen_string_literal: true
 
 require_relative "binary_function"
+require_relative "../../mathml/utility"
 
 module Plurimath
   module Math
     module Function
       class Frac < BinaryFunction
+        include Mathml::Utility
+
         attr_accessor :options
+
         FUNCTION = {
           name: "fraction",
           first_value: "numerator",
@@ -41,7 +45,7 @@ module Plurimath
           frac_tag.set_attr(self.options.reject { |opt| opt == :choose }) if tag_name == "mfrac" && self.options
           Utility.update_nodes(frac_tag, mathml_value)
           update_derivative(frac_tag, mathml_value[0], mathml_value[1]) if intent
-          intentify(frac_tag, intent, func_name: :frac)
+          intentify(frac_tag, intent, func_name: :frac, options: intent_names)
         end
 
         def to_latex(options:)
@@ -98,6 +102,13 @@ module Plurimath
           "#{first_value}⒞#{second_value}"
         end
 
+        def intent_names
+          {
+            derivative: ":derivative",
+            partial_derivative: ":partial-derivative",
+          }
+        end
+
         protected
 
         def fpr_element

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

@@ -36,7 +36,7 @@ module Plurimath
               parameter_two&.to_mathml_without_math_tag(intent, options: options),
             ],
           )
-          intentify(inf_tag, intent, func_name: :function, intent_name: :function)
+          intentify(inf_tag, intent, func_name: :function, intent_name: intent_names[:name])
         end
 
         def to_omml_without_math_tag(display_style, options:)
@@ -57,6 +57,10 @@ module Plurimath
           "inf#{sub_value(options: options)}#{sup_value(options: options)}"
         end
 
+        def intent_names
+          { name: ":function" }
+        end
+
         protected
 
         def sup_value(options:)

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

@@ -62,7 +62,7 @@ module Plurimath
               wrap_mrow(parameter_three&.to_mathml_without_math_tag(intent, options: options), intent),
             ].flatten.compact,
           )
-          intentify(mrow, intent, func_name: :naryand, intent_name: :integral)
+          intentify(mrow, intent, func_name: :naryand, intent_name: intent_names[:name])
         end
 
         def to_omml_without_math_tag(display_style, options:)
@@ -116,6 +116,10 @@ module Plurimath
           true
         end
 
+        def intent_names
+          { name: ":integral" }
+        end
+
         protected
 
         def sup_value(options:)

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

@@ -17,15 +17,19 @@ module Plurimath
           "ⓘ#{first_value}"
         end
 
+        def intent_names
+          { name: ":derivative" }
+        end
+
         private
 
         def encoded_intent(tag)
-          if parameter_two.value == ":derivative" && encodable?
+          if parameter_two.value == intent_names[:name] && encodable?
             field = parameter_one.value
             unicode = encode(field[0].parameter_one.value)
             unfenced_str = fence_value(tag.nodes[1].nodes[1..-2]) if tag.nodes[1]["intent"] == ":fenced"
             fenced_str = "(#{unfenced_str})" unless unfenced_str.empty?
-            ":derivative(1,#{unicode}#{fenced_str},#{unfenced_str})"
+            "#{intent_names[:name]}(1,#{unicode}#{fenced_str},#{unfenced_str})"
           else
             Utility.html_entity_to_unicode(parameter_two.value)
           end

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

@@ -42,7 +42,7 @@ module Plurimath
               parameter_two&.to_mathml_without_math_tag(intent, options: options),
             ],
           )
-          intentify(lim_tag, intent, func_name: :function, intent_name: :function)
+          intentify(lim_tag, intent, func_name: :function, intent_name: intent_names[:name])
         end
 
         def to_omml_without_math_tag(display_style, options:)
@@ -64,6 +64,10 @@ module Plurimath
             self.parameter_two = nil
           end
         end
+
+        def intent_names
+          { name: ":function" }
+        end
       end
     end
   end

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

@@ -17,7 +17,7 @@ module Plurimath
         def ==(object)
           object.class == self.class &&
             object.parameter_one == parameter_one &&
-            object.linebreak == linebreak
+            object.linebreak? == linebreak?
         end
 
         def to_asciimath(options:)
@@ -91,7 +91,7 @@ module Plurimath
           true
         end
 
-        def linebreak
+        def linebreak?
           true
         end
       end

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

@@ -1,11 +1,14 @@
 # frozen_string_literal: true
 
 require_relative "unary_function"
+require_relative "../../mathml/utility"
 
 module Plurimath
   module Math
     module Function
       class Longdiv < UnaryFunction
+        include Mathml::Utility
+
         def to_asciimath(options:)
           asciimath_value(options: options)
         end

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

@@ -1,11 +1,14 @@
 # frozen_string_literal: true
 
 require_relative "binary_function"
+require_relative "../../mathml/utility"
 
 module Plurimath
   module Math
     module Function
       class Menclose < BinaryFunction
+        include Mathml::Utility
+
         FUNCTION = {
           name: "enclosure",
           first_value: "enclosure type",

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

@@ -1,14 +1,17 @@
 # frozen_string_literal: true
 
 require_relative "unary_function"
+require_relative "../../mathml/utility"
 
 module Plurimath
   module Math
     module Function
       class Merror < UnaryFunction
-        def to_asciimath(**);end
+        include Mathml::Utility
 
-        def to_latex(**);end
+        def to_asciimath(**); end
+
+        def to_latex(**); end
 
         def to_mathml_without_math_tag(intent, options:)
           merror = Utility.ox_element("merror")

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

@@ -1,11 +1,14 @@
 # frozen_string_literal: true
 
 require_relative "unary_function"
+require_relative "../../mathml/utility"
 
 module Plurimath
   module Math
     module Function
       class Mglyph < UnaryFunction
+        include Mathml::Utility
+
         def initialize(parameter_one = {})
           super(parameter_one)
         end
@@ -34,8 +37,32 @@ module Plurimath
           parameter_one[:alt] if parameter_one
         end
 
+        def alt; end
+
+        def src; end
+
+        def index; end
+
+        def src=(value)
+          set_option(:src, value)
+        end
+
+        def alt=(value)
+          set_option(:alt, value)
+        end
+
+        def index=(value)
+          set_option(:index, value)
+        end
+
         protected
 
+        def set_option(option, value)
+          return if value.nil?
+
+          parameter_one[option] = value
+        end
+
         def glyph_user_index(index)
           return "" unless index > 0
 

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

@@ -1,11 +1,14 @@
 # frozen_string_literal: true
 
 require_relative "binary_function"
+require_relative "../../mathml/utility"
 
 module Plurimath
   module Math
     module Function
       class Mlabeledtr < BinaryFunction
+        include Mathml::Utility
+
         def to_mathml_without_math_tag(intent, options:)
           table = ox_element("mtable")
           mlabeledtr = ox_element(class_name)
@@ -18,6 +21,22 @@ module Plurimath
           "#{parameter_one&.to_unicodemath(options: options)}##{parameter_two&.value}"
         end
 
+        def id=(value)
+          return if value.nil?
+
+          @parameter_two = Text.new(value)
+        end
+
+        def mtd_value=(value)
+          return if value.nil? || value.empty?
+
+          self.parameter_one = replace_order_with_value(
+            clear_temp_order,
+            update_temp_mathml_values(value),
+            "mtd"
+          )
+        end
+
         protected
 
         def labeledtr_td(tr, value)

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

@@ -1,12 +1,16 @@
 # frozen_string_literal: true
 
 require_relative "unary_function"
+require_relative "../../mathml/utility"
 
 module Plurimath
   module Math
     module Function
       class Mpadded < UnaryFunction
+        include Mathml::Utility
+
         attr_accessor :options
+
         ZERO_TAGS = {
           height: "zeroAsc",
           depth: "zeroDesc",
@@ -58,11 +62,34 @@ module Plurimath
           end
         end
 
+        def voffset; end
+
+        def voffset=(value); end
+
+        def height=(value)
+          set_option(:height, value)
+        end
+
+        def depth=(value)
+          set_option(:depth, value)
+        end
+
+        def width=(value)
+          set_option(:width, value)
+        end
+
         protected
 
+        def set_option(option, value)
+          return if value.nil?
+
+          @options ||= {}
+          @options[option] = value
+        end
+
         def phant_pr
           attributes = { "m:val": "on" }
-          options.map do |atr, value|
+          options&.map do |atr, value|
             ox_element(ZERO_TAGS[atr], attributes: attributes) if attr_value_zero?(value)
           end
         end