plurimath 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6fabed12e1b85fa2c5d7b2cacfebaf2bafb8481025f6f0a9b072649ff2991131
-  data.tar.gz: ec912de1e4e356af0d7458c0b2147ea9aee1fb4676506429ac5e4161cd974c79
+  metadata.gz: af2ed460bf37f3496c528c6cb170f2c555873332771086113f90a875312b467a
+  data.tar.gz: d9311eaf4dfb84c188966346a38d273e544f035c573afb50898bd9f03f81c9fc
 SHA512:
-  metadata.gz: d31d2f5b644402ab58c0f19a9c14e88f91fff26d44dff6c89484b66d45d3760087be0827002c87c3b9ca540ac7dd52ad2ceb014f4b0f6b16fc9f94630f823c70
-  data.tar.gz: 8f5ea828f70451af6ae075d8e06db4055145e096c83fc39b9a31cdcc57ddfff57afdd736e9f696d83e68d7b6c50ada74fa68f46acc00e878e08c1db22050ed2d
+  metadata.gz: cffd311295a1f9e41d372c544909029da3f5798f5744e14e549dd1d7e220755971d5bec0a91cc3695fdef25f3d9b44de606da37876c615eee3cc3818eadbe6e9
+  data.tar.gz: f4035ab63d7f2f3f0aef261f9491ed163a1ffec03d52011b7dda140d6ce4c303bd277a5d05487028b8c77c32585359a826d85fcfc46bb32220e4d1b103b54fb3

data/.gitignore

@@ -6,7 +6,11 @@
 /pkg/
 /spec/reports/
 /tmp/
+/Gemfile.lock
 
 # rspec failure tracking
 .rspec_status
 /coverage/
+
+# temp files
+*.kate-swp

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rspec-opal

@@ -0,0 +1,11 @@
+--default-path=spec
+-I lib
+-q oga/setup_opal
+-q ll/setup_opal
+--opal-opt=-g,htmlentities
+--opal-opt=-g,equivalent-xml
+--opal-opt=-g,parslet
+--opal-opt=-g,oga
+--format documentation
+--color
+--require spec_helper

data/Gemfile

@@ -8,3 +8,6 @@ gem "rspec", "~> 3.0"
 gem 'simplecov', require: false, group: :test
 gem 'htmlentities'
 gem 'equivalent-xml'
+gem 'opal-rspec', "~> 1.1.0a"
+gem 'oga'
+gem 'ox'

data/Rakefile

@@ -1,6 +1,17 @@
+require "erb"
 require "bundler/gem_tasks"
 require "rspec/core/rake_task"
+require 'opal/rspec/rake_task'
 
 RSpec::Core::RakeTask.new(:spec)
 
+# Opal testing support
+begin
+  Opal::RSpec::RakeTask.new(:"spec-opal")
+rescue LoadError
+  # Likely the dependencies haven't been upstreamed yet. Ensure you
+  # run those tests via the `plurimath-js` repo's `env/plurimath`
+  # script.
+end
+
 task :default => :spec

data/lib/plurimath/asciimath/transform.rb

@@ -132,6 +132,13 @@ module Plurimath
         new_arr
       end
 
+      rule(sequence: simple(:sequence),
+           left_right: sequence(:left_right)) do
+        new_arr = [sequence]
+        new_arr += left_right unless left_right.empty?
+        new_arr
+      end
+
       rule(sequence: simple(:sequence),
            number: simple(:number)) do
         [sequence, Math::Number.new(number.to_s)]
@@ -629,6 +636,14 @@ module Plurimath
         sequence.flatten.compact + expr.flatten.compact
       end
 
+      rule(sequence: simple(:sequence),
+           symbol: simple(:symbol)) do
+        [
+          sequence,
+          Math::Symbol.new(symbol),
+        ]
+      end
+
       rule(binary_class: simple(:function),
            base_value: simple(:base)) do
         Utility.get_class(function).new(

data/lib/plurimath/latex/constants.rb

@@ -1720,6 +1720,7 @@ module Plurimath
         cap: "∩",
         cup: "∪",
         sim: "∼",
+        int: "∫",
         neq: "≠",
         leq: "≤",
         geq: "≥",
@@ -2853,6 +2854,7 @@ module Plurimath
         mathbfit: :fonts,
         mathfrak: :fonts,
         overline: :unary,
+        underset: :binary,
         overset: :binary,
         ddagger: :symbols,
         trprime: :symbols,
@@ -3245,6 +3247,7 @@ module Plurimath
         textrm: :fonts,
         textbf: :fonts,
         arccos: :unary,
+        cancel: :unary,
         arcsin: :unary,
         arctan: :unary,
         limsup: :unary,

data/lib/plurimath/latex/parse.rb

@@ -4,11 +4,18 @@ require "parslet"
 module Plurimath
   class Latex
     class Parse < Parslet::Parser
-      rule(:base)       { str("_") }
-      rule(:power)      { str("^") }
-      rule(:slash)      { str("\\") }
-      rule(:under_over) { slash >> underover_classes }
-      rule(:array_args) { (str("{") >> expression.as(:args) >> str("}")) }
+      rule(:base)          { str("_") }
+      rule(:power)         { str("^") }
+      rule(:slash)         { str("\\") }
+      rule(:under_over)    { slash >> underover_classes }
+      rule(:array_args)    { (str("{") >> expression.as(:args) >> str("}")) }
+      rule(:array_begin)   { (str("\\begin{") >> str("array").as(:environment) >> str("}")) }
+      rule(:optional_args) { (str("[") >> intermediate_exp.maybe.as(:options) >> str("]")).maybe }
+
+      rule(:color) do
+        (str("{") >> (str("}").absent? >> any).repeat.as(:symbol) >> str("}")) |
+          any.as(:symbol)
+      end
 
       rule(:optional_args) do
         (str("[") >> intermediate_exp.maybe.as(:options) >> str("]")).maybe
@@ -16,11 +23,7 @@ module Plurimath
 
       rule(:begining) do
         (slash >> str("begin") >> (str("{") >> symbol_text_or_integer >> str("*").as(:asterisk) >> str("}")) >> optional_args.maybe) |
-        (slash >> str("begin") >> (str("{") >> symbol_text_or_integer >> str("}")))
-      end
-
-      rule(:array_begin) do
-        (str("\\begin{") >> str("array").as(:environment) >> str("}"))
+          (slash >> str("begin") >> (str("{") >> symbol_text_or_integer >> str("}")))
       end
 
       rule(:ending) do
@@ -123,7 +126,8 @@ module Plurimath
       rule(:binary_functions) do
         (intermediate_exp.as(:first_value) >> under_over >> intermediate_exp.as(:second_value)).as(:under_over) |
           (slash >> str("sqrt").as(:root) >> sqrt_arg.as(:first_value) >> intermediate_exp.as(:second_value)).as(:binary) |
-          (slash >> str("sqrt").as(:sqrt) >> intermediate_exp.as(:intermediate_exp)).as(:binary)
+          (slash >> str("sqrt").as(:sqrt) >> intermediate_exp.as(:intermediate_exp)).as(:binary) |
+          (color_rules)
       end
 
       rule(:sequence) do
@@ -242,6 +246,11 @@ module Plurimath
           (power >> intermediate_exp.as(:supscript)) |
           (base >> intermediate_exp.as(:subscript))
       end
+
+      def color_rules
+        (str("{") >> slash >> str("color").as(:binary) >> color.as(:first_value) >> (sequence >> iteration.maybe).as(:second_value).maybe >> str("}")) |
+          (slash >> str("color").as(:binary) >> color.as(:first_value) >> expression.as(:second_value).maybe)
+      end
     end
   end
 end

data/lib/plurimath/latex/transform.rb

@@ -516,7 +516,7 @@ module Plurimath
 
       rule(text: simple(:text),
            first_value: sequence(:first_value),
-           subscript: simple(:subscript),) do
+           subscript: simple(:subscript)) do
         Math::Function::Base.new(
           Math::Function::Text.new(first_value.join),
           subscript,
@@ -525,13 +525,24 @@ module Plurimath
 
       rule(text: simple(:text),
            first_value: simple(:first_value),
-           subscript: simple(:subscript),) do
+           subscript: simple(:subscript)) do
         Math::Function::Base.new(
           Math::Function::Text.new(first_value),
           subscript,
         )
       end
 
+      rule(text: simple(:text),
+           first_value: simple(:first_value),
+           subscript: simple(:subscript),
+           supscript: simple(:supscript)) do
+        Math::Function::PowerBase.new(
+          Math::Function::Text.new(first_value),
+          subscript,
+          supscript,
+        )
+      end
+
       rule(unary: simple(:unary),
            first_value: simple(:first_value)) do
         Utility.get_class(
@@ -788,6 +799,17 @@ module Plurimath
         end
       end
 
+      rule(binary: simple(:binary),
+           first_value: simple(:first_value),
+           second_value: sequence(:second_value)) do
+        Utility.get_class(
+          binary.to_s.include?("mod") ? "mod" : binary,
+        ).new(
+          first_value,
+          Utility.filter_values(second_value),
+        )
+      end
+
       rule(underover: simple(:function),
            first_value: simple(:first),
            subscript: simple(:subscript),

data/lib/plurimath/math/core.rb

@@ -64,6 +64,94 @@ module Plurimath
       def font_style_t_tag(display_style)
         to_omml_without_math_tag(display_style)
       end
+
+      def ascii_fields_to_print(field, options = {})
+        return if field.nil?
+
+        hashed = common_math_zone_conversion(field, options)
+        options[:array] << "#{hashed[:spacing]}|_ \"#{field&.to_asciimath}\"#{hashed[:field_name]}\n"
+        return unless Utility.validate_math_zone(field)
+
+        options[:array] << field&.to_asciimath_math_zone(hashed[:function_spacing], hashed[:last], hashed[:indent])
+      end
+
+      def latex_fields_to_print(field, options = {})
+        return if field.nil?
+
+        hashed = common_math_zone_conversion(field, options)
+        options[:array] << "#{hashed[:spacing]}|_ \"#{field&.to_latex}\"#{hashed[:field_name]}\n"
+        return unless Utility.validate_math_zone(field)
+
+        options[:array] << field&.to_latex_math_zone(hashed[:function_spacing], hashed[:last], hashed[:indent])
+      end
+
+      def mathml_fields_to_print(field, options = {})
+        return if field.nil?
+
+        hashed = common_math_zone_conversion(field, options)
+        options[:array] << "#{hashed[:spacing]}|_ \"#{dump_mathml(field)}\"#{hashed[:field_name]}\n"
+        return unless Utility.validate_math_zone(field)
+
+        options[:array] << field&.to_mathml_math_zone(hashed[:function_spacing], hashed[:last], hashed[:indent])
+      end
+
+      def omml_fields_to_print(field, options = {})
+        return if field.nil?
+
+        hashed = common_math_zone_conversion(field, options)
+        display_style = options[:display_style]
+        options[:array] << "#{hashed[:spacing]}|_ \"#{dump_omml(field, display_style)}\"#{hashed[:field_name]}\n"
+        return unless Utility.validate_math_zone(field)
+
+        options[:array] << field&.to_omml_math_zone(hashed[:function_spacing], hashed[:last], hashed[:indent], display_style: display_style)
+      end
+
+      def dump_mathml(field)
+        mathml = dump_ox_nodes(field.to_mathml_without_math_tag)
+        mathml.gsub(/\n\s*/, "").gsub("&amp;", "&")
+      end
+
+      def dump_omml(field, display_style)
+        return if field.nil?
+
+        omml = field.omml_nodes(display_style)
+        omml_string = omml.is_a?(Array) ? omml.flatten.map { |obj| dump_ox_nodes(obj) }.join : dump_ox_nodes(omml)
+        omml_string.gsub(/\n\s*/, "").gsub("&amp;", "&")
+      end
+
+      def omml_nodes(display_style)
+        to_omml_without_math_tag(display_style)
+      end
+
+      def validate_mathml_fields(field)
+        field.nil? ? Utility.ox_element("mi") : field.to_mathml_without_math_tag
+      end
+
+      def common_math_zone_conversion(field, options = {})
+        {
+          spacing: options[:spacing],
+          last: options[:last] || true,
+          indent: !field&.is_a?(Formula),
+          function_spacing: "#{options[:spacing]}#{options[:additional_space]}",
+          field_name: options[:field_name] ?  " #{options[:field_name]}" : "",
+        }
+      end
+
+      def filtered_values(value)
+        @values = Utility.filter_math_zone_values(value)
+      end
+
+      def dump_ox_nodes(nodes)
+        Plurimath.xml_engine.dump(nodes)
+      end
+
+      def gsub_spacing(spacing, last)
+        spacing.gsub(/\|\_/, last ? "  " : "| ")
+      end
+
+      def invert_unicode_symbols
+        Mathml::Constants::UNICODE_SYMBOLS.invert[class_name] || class_name
+      end
     end
   end
 end

data/lib/plurimath/math/formula.rb

@@ -4,6 +4,12 @@ module Plurimath
   module Math
     class Formula < Core
       attr_accessor :value, :left_right_wrapper, :displaystyle, :input_string
+      MATH_ZONE_TYPES = %i[
+        omml
+        latex
+        mathml
+        asciimath
+      ].freeze
 
       def initialize(
         value = [],
@@ -18,7 +24,9 @@ module Plurimath
       end
 
       def ==(object)
-        object.value == value &&
+        object.respond_to?(:value) &&
+          object.respond_to?(:left_right_wrapper) &&
+          object.value == value &&
           object.left_right_wrapper == left_right_wrapper
       end
 
@@ -38,7 +46,7 @@ module Plurimath
         style = Utility.ox_element("mstyle", attributes: style_attrs)
         Utility.update_nodes(style, mathml_content)
         Utility.update_nodes(math, [style])
-        Ox.dump(math, indent: 2).gsub("&amp;", "&")
+        Plurimath.xml_engine.dump(math, indent: 2).gsub("&amp;", "&")
       rescue
         parse_error!(:mathml)
       end
@@ -100,7 +108,7 @@ module Plurimath
         math_element = Utility.ox_element("oMath", namespace: "m")
         content = omml_content(boolean_display_style(display_style))
         para_element << Utility.update_nodes(math_element, content)
-        Ox.dump(para_element, indent: 2).gsub("&amp;", "&").lstrip
+        Plurimath.xml_engine.dump(para_element, indent: 2).gsub("&amp;", "&").lstrip
       rescue
         parse_error!(:omml)
       end
@@ -110,20 +118,54 @@ module Plurimath
       end
 
       def to_omml_without_math_tag(display_style)
-        return nary_tag(display_style) if nary_tag_able?(display_style)
-
         omml_content(display_style)
       end
 
-      def nary_tag(display_style)
-        nary_element = Utility.ox_element("nary", namespace: "m")
-        e_tag    = Utility.ox_element("e", namespace: "m")
-        Utility.update_nodes(e_tag, value.last.insert_t_tag(display_style))
-        Utility.update_nodes(
-          nary_element,
-          (value.first.omml_nary_tag(display_style) << e_tag),
-        )
-        [nary_element]
+      def to_display(type = nil)
+        return type_error! unless MATH_ZONE_TYPES.include?(type.downcase.to_sym)
+
+        math_zone = case type
+                    when :asciimath
+                      "  |_ \"#{to_asciimath}\"\n#{to_asciimath_math_zone("     ").join}"
+                    when :latex
+                      "  |_ \"#{to_latex}\"\n#{to_latex_math_zone("     ").join}"
+                    when :mathml
+                      "  |_ \"#{to_mathml.gsub(/\n\s*/, "")}\"\n#{to_mathml_math_zone("     ").join}"
+                    when :omml
+                      "  |_ \"#{to_omml.gsub(/\n\s*/, "")}\"\n#{to_omml_math_zone("     ", display_style: displaystyle).join}"
+                    end
+        <<~MATHZONE.sub(/\n$/, "")
+        |_ Math zone
+        #{math_zone}
+        MATHZONE
+      end
+
+      def to_asciimath_math_zone(spacing = "", last = false, indent = true)
+        filtered_values(value).map.with_index(1) do |object, index|
+          last = index == @values.length
+          object.to_asciimath_math_zone(new_space(spacing, indent), last, indent)
+        end
+      end
+
+      def to_latex_math_zone(spacing = "", last = false, indent = true)
+        filtered_values(value).map.with_index(1) do |object, index|
+          last = index == @values.length
+          object.to_latex_math_zone(new_space(spacing, indent), last, indent)
+        end
+      end
+
+      def to_mathml_math_zone(spacing = "", last = false, indent = true)
+        filtered_values(value).map.with_index(1) do |object, index|
+          last = index == @values.length
+          object.to_mathml_math_zone(new_space(spacing, indent), last, indent)
+        end
+      end
+
+      def to_omml_math_zone(spacing = "", last = false, indent = true, display_style:)
+        filtered_values(value).map.with_index(1) do |object, index|
+          last = index == @values.length
+          object.to_omml_math_zone(new_space(spacing, indent), last, indent, display_style: display_style)
+        end
       end
 
       def extract_class_from_text
@@ -136,16 +178,6 @@ module Plurimath
         value.first.nary_attr_value
       end
 
-      def nary_tag_able?(display_style)
-        value.length == 2 &&
-          ["underover", "powerbase"].include?(value&.first&.class_name) &&
-          !value.first.parameter_one.is_a?(Function::FontStyle) &&
-          (
-            value&.first&.parameter_one&.to_omml_without_math_tag(display_style)&.length == 1 ||
-            value&.first&.parameter_one.to_omml_without_math_tag(display_style).match?(/^&#x\w*\d*;$/)
-          )
-      end
-
       def validate_function_formula
         (value.none?(Function::Left) || value.none?(Function::Right))
       end
@@ -156,6 +188,18 @@ module Plurimath
         YAML.load(display_style.to_s)
       end
 
+      def new_space(spacing, indent)
+        if value.any? { |val| val.class_name == "left" } && value.any? { |val| val.class_name == "right" }
+          return spacing
+        end
+
+        (indent && wrapable?(spacing)) ? spacing + "|_ " : spacing
+      end
+
+      def wrapable?(spacing)
+        left_right_wrapper && !spacing.end_with?("|_ ")
+      end
+
       def parse_error!(type)
         Math.parse_error!(input_string, type)
       end

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

@@ -6,6 +6,12 @@ module Plurimath
   module Math
     module Function
       class Base < BinaryFunction
+        FUNCTION = {
+          name: "subscript",
+          first_value: "base",
+          second_value: "script",
+        }.freeze
+
         def to_asciimath
           first_value = parameter_one.to_asciimath if parameter_one
           second_value = "_#{wrapped(parameter_two)}" if parameter_two
@@ -16,8 +22,8 @@ module Plurimath
           tag_name = (Utility::MUNDER_CLASSES.include?(parameter_one&.class_name) ? "under" : "sub")
           sub_tag = Utility.ox_element("m#{tag_name}")
           mathml_value = []
-          mathml_value << parameter_one&.to_mathml_without_math_tag
-          mathml_value << parameter_two&.to_mathml_without_math_tag if parameter_two
+          mathml_value << validate_mathml_fields(parameter_one)
+          mathml_value << validate_mathml_fields(parameter_two)
           Utility.update_nodes(sub_tag, mathml_value)
         end
 

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

@@ -64,6 +64,42 @@ module Plurimath
           !(parameter_one.nil? && parameter_two.nil?)
         end
 
+        def to_asciimath_math_zone(spacing, last = false, _)
+          parameters = self.class::FUNCTION
+          new_spacing = gsub_spacing(spacing, last)
+          new_arr = ["#{spacing}\"#{to_asciimath}\" #{parameters[:name]}\n"]
+          ascii_fields_to_print(parameter_one, { spacing: new_spacing, field_name: parameters[:first_value], additional_space: "|  |_ " , array: new_arr })
+          ascii_fields_to_print(parameter_two, { spacing: new_spacing, field_name: parameters[:second_value], additional_space: "   |_ " , array: new_arr })
+          new_arr
+        end
+
+        def to_latex_math_zone(spacing, last = false, _)
+          parameters = self.class::FUNCTION
+          new_spacing = gsub_spacing(spacing, last)
+          new_arr = ["#{spacing}\"#{to_latex}\" #{parameters[:name]}\n"]
+          latex_fields_to_print(parameter_one, { spacing: new_spacing, field_name: parameters[:first_value], additional_space: "|  |_ " , array: new_arr })
+          latex_fields_to_print(parameter_two, { spacing: new_spacing, field_name: parameters[:second_value], additional_space: "   |_ " , array: new_arr })
+          new_arr
+        end
+
+        def to_mathml_math_zone(spacing, last = false, _)
+          parameters = self.class::FUNCTION
+          new_spacing = gsub_spacing(spacing, last)
+          new_arr = ["#{spacing}\"#{dump_mathml(self)}\" #{parameters[:name]}\n"]
+          mathml_fields_to_print(parameter_one, { spacing: new_spacing, field_name: parameters[:first_value], additional_space: "|  |_ ", array: new_arr })
+          mathml_fields_to_print(parameter_two, { spacing: new_spacing, field_name: parameters[:second_value], additional_space: "  |_ ", array: new_arr })
+          new_arr
+        end
+
+        def to_omml_math_zone(spacing, last = false, _, display_style:)
+          parameters = self.class::FUNCTION
+          new_spacing = gsub_spacing(spacing, last)
+          new_arr = ["#{spacing}\"#{dump_omml(self, display_style)}\" #{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 })
+          omml_fields_to_print(parameter_two, { spacing: new_spacing, field_name: parameters[:second_value], additional_space: "  |_ ", array: new_arr, display_style: display_style })
+          new_arr
+        end
+
         protected
 
         def latex_wrapped(field)
@@ -80,10 +116,6 @@ module Plurimath
           "(#{field.to_asciimath})"
         end
 
-        def invert_unicode_symbols
-          Mathml::Constants::UNICODE_SYMBOLS.invert[class_name] || class_name
-        end
-
         def empty_tag(wrapper_tag)
           r_tag = Utility.ox_element("r", namespace: "m")
           r_tag << (Utility.ox_element("t", namespace: "m") << "&#8203;")

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

@@ -6,6 +6,12 @@ module Plurimath
   module Math
     module Function
       class Color < BinaryFunction
+        FUNCTION = {
+          name: "color",
+          first_value: "mathcolor",
+          second_value: "text",
+        }.freeze
+
         def to_asciimath
           first_value = "(#{parameter_one&.to_asciimath&.gsub(/\s/, '')})"
           second_value = "(#{parameter_two&.to_asciimath})"
@@ -31,6 +37,14 @@ module Plurimath
         def to_omml_without_math_tag(display_style)
           Array(parameter_two.insert_t_tag(display_style))
         end
+
+        def to_omml_math_zone(spacing, last = false, _, display_style:)
+          parameters = self.class::FUNCTION
+          new_spacing = gsub_spacing(spacing, last)
+          new_arr = ["#{spacing}\"#{dump_omml(self, display_style)}\" #{parameters[:name]}\n"]
+          omml_fields_to_print(parameter_two, { spacing: new_spacing, field_name: "text", additional_space: "|  |_ ", array: new_arr, display_style: display_style })
+          new_arr
+        end
       end
     end
   end

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

@@ -56,6 +56,33 @@ module Plurimath
           [d]
         end
 
+        def to_asciimath_math_zone(spacing, last = false, indent = true)
+          filtered_values(parameter_two).map.with_index(1) do |object, index|
+            last = index == @values.length
+            object.to_asciimath_math_zone(spacing, last, indent)
+          end
+        end
+
+        def to_latex_math_zone(spacing, last = false, indent = true)
+          filtered_values(parameter_two).map.with_index(1) do |object, index|
+            last = index == @values.length
+            object.to_latex_math_zone(spacing, last, indent)
+          end
+        end
+
+        def to_mathml_math_zone(spacing, last = false, indent = true)
+          filtered_values(parameter_two).map.with_index(1) do |object, index|
+            last = index == @values.length
+            object.to_mathml_math_zone(spacing, last, indent)
+          end
+        end
+
+        def to_omml_math_zone(spacing, last = false, indent = true, display_style:)
+          filtered_values(parameter_two).map.with_index(1) do |object, index|
+            object.to_omml_math_zone(spacing, last, !indent, display_style: display_style)
+          end
+        end
+
         protected
 
         def first_value(dpr)

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

@@ -7,7 +7,7 @@ module Plurimath
     module Function
       class Floor < UnaryFunction
         def to_latex
-          "\\lfloor #{parameter_one.to_latex} \\rfloor"
+          "{\\lfloor #{parameter_one.to_latex} \\rfloor}"
         end
 
         def to_mathml_without_math_tag

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

@@ -59,6 +59,51 @@ module Plurimath
           )
           [r_tag]
         end
+
+        def to_asciimath_math_zone(spacing, last = false, _)
+          new_spacing = gsub_spacing(spacing, last)
+          new_arr = [
+            "#{spacing}\"#{to_asciimath}\" function apply\n",
+            "#{new_spacing}|_ \"#{parameter_two}\" font family\n",
+          ]
+          ascii_fields_to_print(parameter_one, { spacing: new_spacing, field_name: "argument", additional_space: "|  |_ " , array: new_arr })
+          new_arr
+        end
+
+        def to_latex_math_zone(spacing, last = false, _)
+          new_spacing = gsub_spacing(spacing, last)
+          new_arr = [
+            "#{spacing}\"#{to_latex}\" function apply\n",
+            "#{new_spacing}|_ \"#{parameter_two}\" font family\n",
+          ]
+          latex_fields_to_print(parameter_one, { spacing: new_spacing, field_name: "argument", additional_space: "|  |_ " , array: new_arr })
+          new_arr
+        end
+
+        def to_mathml_math_zone(spacing, last = false, _)
+          new_spacing = gsub_spacing(spacing, last)
+          new_arr = [
+            "#{spacing}\"#{dump_mathml(self)}\" function apply\n",
+            "#{new_spacing}|_ \"#{omml_and_mathml_font_family}\" font family\n",
+          ]
+          mathml_fields_to_print(parameter_one, { spacing: new_spacing, field_name: "argument", additional_space: "|  |_ ", array: new_arr })
+          new_arr
+        end
+
+        def to_omml_math_zone(spacing, last = false, _, display_style:)
+          new_spacing = gsub_spacing(spacing, last)
+          new_arr = [
+            "#{spacing}\"#{dump_omml(self, display_style)}\" function apply\n",
+            "#{new_spacing}|_ \"#{omml_and_mathml_font_family}\" font family\n",
+          ]
+          omml_fields_to_print(parameter_one, { spacing: new_spacing, field_name: "argument", additional_space: "|  |_ ", array: new_arr, display_style: display_style })
+          new_arr
+        end
+
+        def omml_and_mathml_font_family
+          fonts = Utility::FONT_STYLES.select { |_font, font_class| font_class == self.class }.keys.map(&:to_s)
+          Omml::Parser::SUPPORTED_FONTS.values.find { |value| fonts.include?(value) }
+        end
       end
     end
   end