plurimath 0.8.17 → 0.8.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f232ae9e7e95e99742976ce89205bd3a21269cfaf2df31941de6fbd9594aff9e
-  data.tar.gz: 93a5a1f1e6faf693ea589c17cb0429aaba81426c838ce9c993747c8db185beb4
+  metadata.gz: 766097c1faa26dc82f8664fca18a302b52920df2fce4ec8395cf2f65d8a7d687
+  data.tar.gz: 35cf1a6b6a0e87fa5404b3eea87927cd69da535deeebfcd49f8db5ce1aaba8e6
 SHA512:
-  metadata.gz: 41e48748d0e213ee5910a6e5e6fcf2d012e87bc7a0731d1036b2e432e40677460c841fe50340763cf7c8778a9ac30ed91c2f1b6795b601bb2ad843f148a2cebc
-  data.tar.gz: 5262d5b7474b0544c82937e50e1b44342d2b2b64aa85adadf4b9a5ec0f9afbbfb23db8d45e514c25745c326c22aef8eae8321ad699a803e04ed084793c9d86e3
+  metadata.gz: 7307ab95dc0d60e6fe65c939665e08ec59902527a454427956ee17e6d2c7bc207921e529ae107d51ec0f2a2a0909cd7da260943d277a03755efc34aa01edd2d0
+  data.tar.gz: 6f050eb9cae6730e911ccae66afe0a4384ab0fade68810fa4fa176e15d5f37eef225f0b11c1409fcd10ed05e75cbf7aa6fdd10a4e18d85ab335dbb947c22d350

data/Gemfile

@@ -11,5 +11,5 @@ gem 'equivalent-xml'
 gem 'opal-rspec', "~> 1.1.0a"
 gem 'oga'
 gem 'ox'
-gem "unitsml"
+gem "unitsml", "0.2.9"
 gem "debug"

data/lib/plurimath/asciimath/parse.rb

@@ -158,6 +158,7 @@ module Plurimath
           str("") |
           (rparen.as(:rparen) >> space? >> controversial_symbols >> comma.as(:comma).maybe >> expression).repeat(1).as(:expr) |
           (power.as(:symbol) >> space? >> expression).as(:expr) |
+          table.as(:table) >> space? >> rparen.as(:rparen) >> space? >> expression.as(:expr).maybe |
           comma.as(:comma).maybe
       end
 

data/lib/plurimath/asciimath/transform.rb

@@ -900,6 +900,18 @@ module Plurimath
         Math::Formula.new(formula_array)
       end
 
+      rule(table: simple(:table),
+           rparen: simple(:rparen),
+           expr: sequence(:expr)) do
+        [
+          Math::Function::Fenced.new(
+            Math::Symbols::Paren::OpenParen.new,
+            [table],
+            Utility.asciimath_symbol_object(rparen),
+          ),
+        ] + expr.flatten.compact
+      end
+
       rule(left: simple(:left),
            left_right_value: simple(:left_right),
            right: simple(:right)) do

data/lib/plurimath/math/core.rb

@@ -8,6 +8,13 @@ module Plurimath
         /^\n/ => "",
       }.freeze
 
+      ALL_PARAMETERS = %i[
+        parameter_one
+        parameter_two
+        parameter_three
+        parameter_four
+      ].freeze
+
       def self.inherited(subclass)
         @descendants ||= []
         @descendants << subclass
@@ -201,7 +208,7 @@ module Plurimath
         false
       end
 
-      def linebreak
+      def linebreak?
         false
       end
 
@@ -291,11 +298,15 @@ module Plurimath
         is_a?(Math::Function::UnaryFunction)
       end
 
-      def is_nary_function?;end
+      def is_nary_function?; end
+
+      def is_nary_symbol?; end
 
-      def is_nary_symbol?;end
+      def nary_intent_name; end
 
-      def nary_intent_name;end
+      def symbol?
+        is_a?(Math::Symbols::Symbol)
+      end
 
       def is_binary_function?
         is_a?(Function::BinaryFunction)
@@ -323,8 +334,56 @@ module Plurimath
         Utility.primes_constants.any? { |prefix, prime| unicodemath_field_value(field).include?(prime) }
       end
 
+      def paren?
+        false
+      end
+
+      def pretty_print_instance_variables
+        excluded_vars = [
+          :@left_right_wrapper,
+          :@temp_mathml_order,
+          :@using_default,
+          :@displaystyle,
+          :@__ordered,
+          :@__mixed,
+          :@is_mrow,
+          :@values,
+        ]
+        instance_variables.sort - excluded_vars
+      end
+
+      def to_ms_value
+        new_arr = []
+        case self
+        when Math::Symbols::Symbol
+          new_arr << (value ? value.to_s : to_unicodemath(options: {}))
+        when Math::Number, Math::Function::Text
+          new_arr << value
+        else
+          parameters_to_ms_value(new_arr)
+          if respond_to?(:value) && value.is_a?(Array)
+            new_arr << value&.map { |element| element.to_ms_value }.join(" ")
+          end
+        end
+        new_arr
+      end
+
+      def is_mstyle?
+        false
+      end
+
+      def is_mrow?
+        false
+      end
+
       private
 
+      def parameters_to_ms_value(array)
+        ALL_PARAMETERS.each do |field|
+          array << get("@#{field}")&.to_ms_value if respond_to?(field)
+        end
+      end
+
       def array_line_break_field(field, variable, obj)
         if result(field).length > 1
           updated_object_values(variable, obj: obj)

data/lib/plurimath/math/formula/mrow.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+module Plurimath
+  module Math
+    class Formula
+      class Mrow < Formula
+        attr_accessor :is_mrow
+
+        def initialize(
+          value = [],
+          left_right_wrapper = true,
+          display_style: true,
+          input_string: nil,
+          unitsml: false
+        )
+          super
+          @is_mrow = true
+        end
+
+        def element_order=(value)
+          @value = validated_order(value, rejectable_array: ["comment"])
+        end
+
+        def content; end
+
+        def content=(value)
+          arr_value = Array(value)
+          if no_content_in?(arr_value)
+            delete_all_text
+          else
+            validate_text_order(
+              arr_value.map { |val| validate_symbols(val) unless val.strip.empty? }
+            )
+          end
+          organize_value
+        end
+
+        def is_mrow?
+          @is_mrow
+        end
+
+        private
+
+        def organize_value
+          return if value.any?(String)
+          return unless is_mrow
+
+          value.each_with_index do |element, index|
+            update_current_element(element, value, index)
+            if value[index + 1].is_a?(Math::Function::Mod)
+              update_mod_function(value, index)
+            elsif unary_function_updatable?(value, element, index)
+              unary_function_update(value, index)
+            elsif value.first.paren? && value.last.paren?
+              organize_fencing(value)
+            elsif valid_underset_function?(element)
+              value[index] = new_nary_element(element, value)
+            elsif valid_underover_function?(element)
+              replace_with_nary_function(element, value, index)
+            elsif ternary_function_third_value_present?(element)
+              element.parameter_three = value.delete_at(index + 1)
+            end
+          end
+        end
+
+        def update_current_element(element, value, index)
+          if first_and_last_values_nil?(value)
+            replace_symbols_with_parens(value)
+          elsif element.class_name == "symbol" && element.value.nil?
+            element.value = ""
+          end
+        end
+
+        def validate_text_order(value)
+          @value.each_with_index do |item, index|
+            next unless item == "text"
+
+            if value.first
+              @value[index] = value.shift
+            else
+              value.shift
+              @value.delete_at(index)
+            end
+          end
+        end
+
+        def delete_all_text
+          @value.delete("text")
+        end
+
+        def no_content_in?(value)
+          value.nil? || value.empty? || value&.all? { |val| val.strip.empty? }
+        end
+
+        def first_and_last_values_nil?(value)
+          value.first.class_name == "symbol" &&
+            value.first.value.nil? &&
+            value.last.class_name == "symbol" &&
+            value.last.value.nil?
+        end
+
+        def replace_symbols_with_parens(value)
+          value[0] = Math::Symbols::Paren::OpenParen.new
+          value[-1] = Math::Symbols::Paren::CloseParen.new
+        end
+
+        def nary_function_or_symbol?(element)
+          element.is_nary_function? || element.is_nary_symbol?
+        end
+
+        def valid_underover_function?(element)
+          element.is_a?(Math::Function::Underover) &&
+            nary_function_or_symbol?(element.parameter_one)
+        end
+
+        def valid_underset_function?(element)
+          element.is_a?(Math::Function::Underset) &&
+            nary_function_or_symbol?(element.parameter_two)
+        end
+
+        def unary_function_updatable?(value, element, index)
+          value.length > 1 &&
+              element.is_unary? &&
+              value[index + 1] &&
+              Plurimath::Utility::UNARY_CLASSES.include?(element.class_name)
+        end
+
+        def ternary_function_third_value_present?(element)
+          element.is_ternary_function? &&
+            element.any_value_exist? &&
+            element.parameter_three.nil?
+        end
+
+        def update_mod_function(value, index)
+          mod_obj = value[index + 1]
+          mod_obj.parameter_one = filter_values(
+            value.delete_at(index),
+            array_to_instance: true
+          )
+          mod_obj.parameter_two = filter_values(
+            value.delete_at(index + 1),
+            array_to_instance: true
+          )
+        end
+
+        def unary_function_update(value, index)
+          element = value.delete_at(index)
+          element.parameter_one = filter_values(
+            value.delete_at(index),
+            array_to_instance: true
+          )
+          value.insert(index, element)
+        end
+
+        def organize_fencing(value)
+          if value[1].is_a?(Math::Function::Table) && value.length == 3
+            table = value[1]
+            table.open_paren = value.shift
+            table.close_paren = value.pop
+          else
+            @value = [
+              Function::Fenced.new(value.shift, value, value.pop)
+            ]
+          end
+        end
+
+        def new_nary_element(element, value)
+          value.shift
+          nary = Plurimath::Math::Function::Nary.new(
+            element.parameter_two,
+            element.parameter_one,
+            nil,
+            filter_values(value.shift(value.length), array_to_instance: true),
+            { type: "undOvr" }
+          )
+          nary
+        end
+
+        def replace_with_nary_function(element, value, index)
+          fourth_value = value.delete_at(index + 1)
+          organize_value(fourth_value) if fourth_value.is_mrow?
+          value[index] = Math::Function::Nary.new(
+            element.parameter_one,
+            element.parameter_two,
+            element.parameter_three,
+            filter_values(fourth_value, array_to_instance: true),
+            { type: "undOvr" }
+          )
+        end
+      end
+    end
+  end
+end

data/lib/plurimath/math/formula/mstyle.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Plurimath
+  module Math
+    class Formula
+      class Mstyle < Formula
+        def displaystyle=(value)
+          @displaystyle = boolean_display_style(value)
+        end
+
+        def is_mstyle?
+          true
+        end
+      end
+    end
+  end
+end