plurimath 0.8.17 → 0.8.19

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,7 +296,6 @@ module Plurimath
         update(Array(value) + values)
       end
 
-
       def mini_sized?
         true if value&.first&.mini_sized?
       end
@@ -304,8 +307,302 @@ module Plurimath
         }
       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
@@ -332,11 +629,11 @@ module Plurimath
       end
 
       def unitsml_post_processing(nodes, prev_node)
+        insert_index = 0
         nodes.each.with_index do |node, index|
           if node[:unitsml]
-            pre_index = index - 1
-            pre_node = nodes[pre_index] if pre_index.zero? || pre_index.positive?
-            prev_node.insert_in_nodes(index, space_element(node)) if valid_previous?(pre_node)
+            prev_node.insert_in_nodes(index + insert_index, space_element(node))
+            insert_index += 1
             node.remove_attr("unitsml")
           end
           unitsml_post_processing(node.nodes, node) if node.nodes.none?(String)
@@ -351,19 +648,10 @@ module Plurimath
 
       def space_element(node)
         element = (ox_element("mo") << "&#x2062;")
-        element[:rspace] = "thickmathspace" if text_in_tag?(node.xml_nodes.nodes)
+        element[:rspace] = "thickmathspace"
         element
       end
 
-      def text_in_tag?(nodes)
-        next_nodes = nodes.first.nodes
-        if next_nodes.all?(String)
-          Utility.html_entity_to_unicode(next_nodes.first).match?(/\p{L}|\p{N}/)
-        else
-          text_in_tag?(next_nodes)
-        end
-      end
-
       def negated_value?
         value.last.is_a?(Math::Symbols::Symbol) && value.last.value == "&#x338;"
       end
@@ -373,21 +661,6 @@ module Plurimath
         value&.map { |v| v.to_unicodemath(options: options) }&.join(join_str)
       end
 
-      def valid_previous?(previous)
-        return unless previous
-
-        ["mi", "mn"].include?(previous.name) ||
-          inside_tag?(previous)
-      end
-
-      def inside_tag?(previous)
-        previous&.nodes&.any? do |node|
-          next if node.is_a?(String)
-
-          valid_previous?(node) if node.xml_node?
-        end
-      end
-
       def intent_attribute(mathml)
         return unless mathml || value.length != 2
         return unless valid_first_parameter?(value.first)
@@ -561,7 +834,7 @@ 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
@@ -699,6 +972,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/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