plurimath 0.8.17 → 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,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
@@ -561,7 +858,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 +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/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

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(
@@ -157,8 +160,220 @@ module Plurimath
           }
         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?
@@ -359,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",

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