plurimath 0.8.16 → 0.8.18

data/lib/plurimath/math/formula.rb

@@ -1,8 +1,12 @@
 # frozen_string_literal: true
 
+require_relative "../mathml/utility"
+
 module Plurimath
   module Math
     class Formula < Core
+      include Mathml::Utility
+
       attr_accessor :value, :left_right_wrapper, :displaystyle, :input_string, :unitsml, :unitsml_xml
 
       MATH_ZONE_TYPES = %i[
@@ -168,7 +172,7 @@ module Plurimath
 
       def to_display(type = nil, formatter: nil)
         options = { formatter: formatter }
-        return type_error! unless MATH_ZONE_TYPES.include?(type.downcase.to_sym)
+        return type_error!(type) unless MATH_ZONE_TYPES.include?(type.downcase.to_sym)
 
         math_zone = case type
                     when :asciimath
@@ -246,7 +250,7 @@ module Plurimath
       end
 
       def update(object)
-        self.value = Array(object)
+        @value = Array(object).flatten.compact
       end
 
       def cloned_objects
@@ -292,13 +296,313 @@ module Plurimath
         update(Array(value) + values)
       end
 
-
       def mini_sized?
         true if value&.first&.mini_sized?
       end
 
+      def intent_names
+        {
+          partial_derivative: ":partial-derivative",
+          derivative: ":derivative",
+        }
+      end
+
+      def element_order=(value)
+        @value = validated_order(value)
+      end
+
+      # Attributes start
+      def mathcolor=(value)
+        return if value.nil? || value.empty?
+
+        update(
+          [
+            Math::Function::Color.new(
+              Math::Function::Text.new(value),
+              filter_values(@value, array_to_instance: true),
+            )
+          ]
+        )
+      end
+
+      def mathvariant=(value)
+        return if value.nil? || value.empty?
+        return unless Plurimath::Utility::FONT_STYLES.key?(value.to_sym)
+
+        update(
+          [
+            Plurimath::Utility::FONT_STYLES[value.to_sym].new(
+              filter_values(@value, array_to_instance: true),
+              value,
+            )
+          ]
+        )
+      end
+
+      def intent=(value)
+        return unless value
+
+        self.content = nil
+        update(
+          [
+            Function::Intent.new(
+              filter_values(@value, array_to_instance: true),
+              Function::Text.new(value),
+            )
+          ]
+        )
+      end
+      # Attributes end
+
+      def ms_value=(value)
+        return if value.nil? || value.empty?
+
+        update(
+          replace_order_with_value(
+            @value,
+            Array(validate_symbols(value)),
+            "ms"
+          )
+        )
+      end
+
+      def mi_value=(value)
+        return if value.nil? || value.empty?
+
+        value = update_temp_mathml_values(value) if value.any? do |val|
+          val.is_a?(Math::Core) && val.temp_mathml_order.any?
+        end
+        update(
+          replace_order_with_value(
+            @value,
+            Array(validate_symbols(value)).flatten,
+            "mi"
+          )
+        )
+      end
+
+      def mn_value=(value)
+        return if value.nil? || value.empty?
+
+        update(
+          replace_order_with_value(
+            @value,
+            Array(validate_symbols(value)),
+            "mn"
+          )
+        )
+      end
+
+      def mtext_value=(value)
+        return if value.nil? || value.empty?
+
+        update(
+          replace_order_with_value(
+            @value,
+            Array(validate_symbols(value)),
+            "mtext"
+          )
+        )
+      end
+
+      def mo_value=(value)
+        return if value.nil? || value.empty?
+
+        value = update_temp_mathml_values(value)
+        update(
+          replace_order_with_value(
+            @value,
+            Array(value),
+            "mo"
+          )
+        )
+      end
+
+      def mstyle_value=(value)
+        return if value.empty?
+
+        update(
+          filter_values(
+            replace_order_with_value(
+              @value,
+              Array(filter_values(value, array_to_instance: true)),
+              "mstyle"
+            )
+          )
+        )
+      end
+
+      def mrow_value=(value)
+        return if value.nil? || value.empty?
+
+        replacing_order = value.length > 1 && value.any?(String)
+        update(
+          replace_order_with_value(
+            @value,
+            filter_values(
+              value,
+              array_to_instance: true,
+              replacing_order: replacing_order
+            ),
+            "mrow"
+          )
+        )
+      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 mroot_value=(value)
+        update_temp_order(value, "mroot")
+      end
+
+      def msgroup_value=(value)
+        update_temp_order(value, "msgroup")
+      end
+
+      def mscarries_value=(value)
+        update_temp_order(value, "mscarries")
+      end
+
+      def msline_value=(value)
+        update_temp_order(value, "msline")
+      end
+
+      def msrow_value=(value)
+        update_temp_order(value, "msrow")
+      end
+
+      def semantics_value=(value)
+        update_temp_order(value, "semantics")
+      end
+
+      def mstack_value=(value)
+        update_temp_order(value, "mstack")
+      end
+
+      def merror_value=(value)
+        return if value.nil? || value.empty?
+
+        update(
+          replace_order_with_value(
+            @value,
+            filter_values(update_temp_mathml_values(value)),
+            "merror"
+          )
+        )
+      end
+
+      def mlongdiv_value=(value)
+        update_temp_order(value, "mlongdiv")
+      end
+
+      def none_value=(_)
+        @value&.delete("none")
+      end
+
+      def maligngroup_value=(value)
+        @value&.delete("maligngroup")
+      end
+
+      def menclose_value=(value)
+        update_temp_order(value, "menclose")
+      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(
+              @value,
+              [linebreak],
+              "mspace"
+            )
+          )
+        else
+          @value&.delete("mspace")
+        end
+      end
+
+      def malignmark_value=(value)
+        @value&.delete("malignmark")
+      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
+
+      def mglyph_value=(value)
+        update_temp_order(value, "mglyph")
+      end
+
       protected
 
+      def update_temp_order(value, order_name)
+        return if value.nil? || value.empty?
+
+        update(
+          replace_order_with_value(
+            Array(@value),
+            Array(update_temp_mathml_values(value)),
+            order_name
+          )
+        )
+      end
+
+      def remove_order(order)
+        value.delete_if { |val| val.is_a?(String) && val == order }
+      end
+
       def boolean_display_style(display_style = displaystyle)
         YAML.safe_load(display_style.to_s)
       end
@@ -489,7 +793,7 @@ module Plurimath
           prime_str = encode(nodes.last.nodes.first) if valid_prime?(nodes.last)
           second_arg.insert(-1, prime_str) unless second_arg.match?(/[0-9]$/)
         end
-        ":partial-derivative(#{first_arg},$f,#{second_arg})"
+        "#{intent_names[:partial_derivative]}(#{first_arg},$f,#{second_arg})"
       end
 
       def f_arg(tag_nodes, index)
@@ -554,14 +858,14 @@ module Plurimath
             mrow_nodes << nodes.delete_at(1)
             next
           when "mrow"
-            second_arg = mrow_nodes.map { |node| encode(node.nodes.first) }.join
+            second_arg = mrow_nodes.map { |n| encode(n.nodes.first) }.join
             third_arg  = upcase_dd_intent_name(node.nodes[1..-2])
             mrow_nodes << nodes.delete_at(1)
             break
           end
           break
         end
-        intent_name = ":derivative(1,#{second_arg},#{third_arg})"
+        intent_name = "#{intent_names[:derivative]}(1,#{second_arg},#{third_arg})"
         mrow = ox_element("mrow", attributes: { intent: intent_name })
         nodes.insert(0, Utility.update_nodes(mrow, mrow_nodes))
       end
@@ -576,7 +880,7 @@ module Plurimath
 
           if DERIVATIVE_CONSTS.include?(node.nodes[0]&.nodes&.first)
             iteration += 1
-            node["intent"] = ":derivative#{derivative_intent_name(node.nodes[1], nodes[iteration..-1], type: node.name)}"
+            node["intent"] = "#{intent_names[:derivative]}#{derivative_intent_name(node.nodes[1], nodes[iteration..-1], type: node.name)}"
             next_node = nodes[iteration]
             case next_node.name
             when "mi", "mrow"
@@ -692,6 +996,12 @@ module Plurimath
         encode(str)
       end
       # Dd derivative nodes end
+
+      def type_error!(type)
+        raise Math::InvalidTypeError.new(
+          "Invalid type provided: #{type}. Must be one of #{MATH_ZONE_TYPES.join(', ')}.",
+        )
+      end
     end
   end
 end

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

@@ -14,7 +14,7 @@ module Plurimath
           first_value = first_value&.insert(0, symbol) unless open_paren
           first_value << symbol unless close_paren
           mrow = Utility.update_nodes(ox_element("mrow"), first_value)
-          intentify(mrow, intent, func_name: :abs, intent_name: :"absolute-value")
+          intentify(mrow, intent, func_name: :abs, intent_name: intent_names[:name])
         end
 
         def to_omml_without_math_tag(display_style, options:)
@@ -39,6 +39,10 @@ module Plurimath
           "⒜#{unicodemath_parens(parameter_one, options: options)}"
         end
 
+        def intent_names
+          { name: "absolute-value" }
+        end
+
         protected
 
         def md_tag

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

@@ -1,12 +1,16 @@
 # frozen_string_literal: true
 
 require_relative "binary_function"
+require_relative "../../mathml/utility"
 
 module Plurimath
   module Math
     module Function
       class Base < BinaryFunction
+        include Mathml::Utility
+
         attr_accessor :options
+
         FUNCTION = {
           name: "subscript",
           first_value: "base",

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

@@ -7,6 +7,7 @@ module Plurimath
     module Function
       class Color < BinaryFunction
         attr_accessor :options
+
         FUNCTION = {
           name: "color",
           first_value: "mathcolor",
@@ -27,11 +28,10 @@ module Plurimath
         end
 
         def to_mathml_without_math_tag(intent, options:)
-          color_value = parameter_one&.to_asciimath(options: options)&.gsub(/\s/, "")&.gsub(/"/, "")
           Utility.update_nodes(
             Utility.ox_element(
               "mstyle",
-              attributes: { attr_key => color_value },
+              attributes: mathml_options,
             ),
             [parameter_two&.to_mathml_without_math_tag(intent, options: options)],
           )
@@ -56,13 +56,26 @@ module Plurimath
         end
 
         def to_unicodemath(options:)
-          "✎(#{parameter_one.to_unicodemath(options: options)}&#{parameter_two.to_unicodemath(options: options)})"
+          "#{color_symbol}(#{parameter_one.to_unicodemath(options: options)}&#{parameter_two.to_unicodemath(options: options)})"
         end
 
         protected
 
+        def color_symbol
+          options&.dig(:backgroundcolor) ? "☁" : "✎"
+        end
+
         def attr_key
-          (options && options[:backcolor]) ? :mathbackground : :mathcolor
+          options&.dig(:backgroundcolor) ? :mathbackground : :mathcolor
+        end
+
+        def mathml_options
+          return unless parameter_one
+
+          color_options = {}
+          color_options[attr_key] =
+            parameter_one.to_asciimath(options: options)&.gsub(/\s/, "")&.gsub(/"/, "")
+          color_options
         end
       end
     end