plurimath 0.8.3 → 0.8.5

data/lib/plurimath/asciimath/transform.rb

@@ -7,10 +7,10 @@ module Plurimath
       rule(frac: simple(:frac))     { frac }
       rule(unary: simple(:unary))   { unary }
       rule(table: simple(:table))   { table }
-      rule(comma: simple(:comma))   { Utility.symbol_object(comma) }
+      rule(comma: simple(:comma))   { Utility.asciimath_symbol_object(comma) }
       rule(slash: simple(:slash))   { Math::Function::Linebreak.new }
       rule(unary: sequence(:unary)) { Utility.filter_values(unary) }
-      rule(rparen: simple(:rparen)) { Utility.symbol_object(rparen) }
+      rule(rparen: simple(:rparen)) { Utility.asciimath_symbol_object(rparen) }
       rule(number: simple(:number)) { Math::Number.new(number) }
 
       rule(ternary: simple(:ternary))       { ternary }
@@ -34,7 +34,7 @@ module Plurimath
 
       rule(bold_fonts: simple(:font)) do
         Math::Function::FontStyle::DoubleStruck.new(
-          Utility.symbol_object(font.to_s[0]),
+          Utility.asciimath_symbol_object(font.to_s[0]),
           "mathbf",
         )
       end
@@ -56,9 +56,7 @@ module Plurimath
       end
 
       rule(symbol: simple(:symbol)) do
-        Utility.symbol_object(
-          (Constants::SYMBOLS[symbol.to_sym] || symbol).to_s,
-        )
+        Utility.asciimath_symbol_object(symbol)
       end
 
       rule(expr: subtree(:expr)) do
@@ -163,38 +161,38 @@ module Plurimath
 
       rule(comma: simple(:comma),
            expr: simple(:expr)) do
-        new_arr = [Utility.symbol_object(comma)]
+        new_arr = [Utility.asciimath_symbol_object(comma)]
         new_arr << expr unless expr.to_s.strip.empty?
         new_arr
       end
 
       rule(comma: simple(:comma),
            expr: sequence(:expr)) do
-        expr.flatten.compact.insert(0, Utility.symbol_object(comma))
+        expr.flatten.compact.insert(0, Utility.asciimath_symbol_object(comma))
       end
 
       rule(symbol: simple(:symbol),
            expr: sequence(:expr)) do
-        expr.flatten.compact.insert(0, Utility.symbol_object(symbol))
+        expr.flatten.compact.insert(0, Utility.asciimath_symbol_object(symbol))
       end
 
       rule(rparen: simple(:rparen),
            expr: simple(:expr)) do
         [
-          Utility.symbol_object(rparen),
+          Utility.asciimath_symbol_object(rparen),
           expr,
         ]
       end
 
       rule(rparen: simple(:rparen),
            expr: sequence(:expr)) do
-        expr.flatten.compact.insert(0, Utility.symbol_object(rparen))
+        expr.flatten.compact.insert(0, Utility.asciimath_symbol_object(rparen))
       end
 
       rule(rparen: simple(:rparen),
            power: simple(:power)) do
         Math::Function::Power.new(
-          Utility.symbol_object(rparen),
+          Utility.asciimath_symbol_object(rparen),
           Utility.unfenced_value(power),
         )
       end
@@ -203,7 +201,7 @@ module Plurimath
            power: simple(:power),
            expr: simple(:expr)) do
         power_object = Math::Function::Power.new(
-          Utility.symbol_object(rparen),
+          Utility.asciimath_symbol_object(rparen),
           Utility.unfenced_value(power),
         )
         new_arr = [power_object]
@@ -215,7 +213,7 @@ module Plurimath
            power: simple(:power),
            expr: sequence(:expr)) do
         power_object = Math::Function::Power.new(
-          Utility.symbol_object(rparen),
+          Utility.asciimath_symbol_object(rparen),
           Utility.unfenced_value(power),
         )
         new_arr = [power_object]
@@ -226,7 +224,7 @@ module Plurimath
       rule(rparen: simple(:rparen),
            base: simple(:base)) do
         Math::Function::Base.new(
-          Utility.symbol_object(rparen),
+          Utility.asciimath_symbol_object(rparen),
           Utility.unfenced_value(base),
         )
       end
@@ -235,7 +233,7 @@ module Plurimath
            base: simple(:base),
            expr: simple(:expr)) do
         base_object = Math::Function::Base.new(
-          Utility.symbol_object(rparen),
+          Utility.asciimath_symbol_object(rparen),
           Utility.unfenced_value(base),
         )
         new_arr = [base_object]
@@ -248,10 +246,10 @@ module Plurimath
            comma: simple(:comma)) do
         [
           Math::Function::Power.new(
-            Utility.symbol_object(rparen),
+            Utility.asciimath_symbol_object(rparen),
             Utility.unfenced_value(power),
           ),
-          Utility.symbol_object(comma),
+          Utility.asciimath_symbol_object(comma),
         ]
       end
 
@@ -260,12 +258,12 @@ module Plurimath
            comma: simple(:comma),
            expr: simple(:expr)) do
         exponent = Math::Function::Power.new(
-          Utility.symbol_object(rparen),
+          Utility.asciimath_symbol_object(rparen),
           Utility.unfenced_value(power),
         )
         new_arr = [
           exponent,
-          Utility.symbol_object(comma),
+          Utility.asciimath_symbol_object(comma),
         ]
         new_arr << expr unless expr.to_s.strip.empty?
         new_arr
@@ -276,12 +274,12 @@ module Plurimath
            comma: simple(:comma),
            expr: sequence(:expr)) do
         exponent = Math::Function::Power.new(
-          Utility.symbol_object(rparen),
+          Utility.asciimath_symbol_object(rparen),
           Utility.unfenced_value(power),
         )
         new_arr = [
           exponent,
-          Utility.symbol_object(comma),
+          Utility.asciimath_symbol_object(comma),
         ]
         new_arr += expr
         new_arr
@@ -292,17 +290,17 @@ module Plurimath
            comma: simple(:comma)) do
         [
           Math::Function::Base.new(
-            Utility.symbol_object(rparen),
+            Utility.asciimath_symbol_object(rparen),
             Utility.unfenced_value(base),
           ),
-          Utility.symbol_object(comma),
+          Utility.asciimath_symbol_object(comma),
         ]
       end
 
       rule(comma: simple(:comma),
            left_right: simple(:left_right)) do
         [
-          Utility.symbol_object(comma),
+          Utility.asciimath_symbol_object(comma),
           left_right,
         ]
       end
@@ -432,8 +430,8 @@ module Plurimath
 
       rule(power_base: simple(:power_base),
            base: simple(:base)) do
-        if base.is_a?(Math::Formula) && base.value.any? { |value| Utility.symbol_value(value, ",") }
-          sliced = base.value.slice_before { |object| Utility.symbol_value(object, ",") }.to_a
+        if base.is_a?(Math::Formula) && base.value.any? { |value| value.is_a?(Math::Symbols::Comma) }
+          sliced = base.value.slice_before { |object| object.is_a?(Math::Symbols::Comma) }.to_a
           base_object = Math::Function::Base.new(
             power_base,
             Utility.filter_values(
@@ -519,7 +517,7 @@ module Plurimath
            base_value: simple(:base_value),
            power_value: simple(:power_value)) do
         Math::Function::PowerBase.new(
-          Utility.symbol_object(rparen),
+          Utility.asciimath_symbol_object(rparen),
           Utility.unfenced_value(base_value),
           Utility.unfenced_value(power_value),
         )
@@ -530,7 +528,7 @@ module Plurimath
            power_value: simple(:power_value),
            expr: simple(:expr)) do
         power_base = Math::Function::PowerBase.new(
-          Utility.symbol_object(rparen),
+          Utility.asciimath_symbol_object(rparen),
           Utility.unfenced_value(base_value),
           Utility.unfenced_value(power_value),
         )
@@ -544,7 +542,7 @@ module Plurimath
            power_value: simple(:power_value),
            expr: simple(:expr)) do
         power_base = Math::Function::PowerBase.new(
-          Utility.symbol_object(rparen),
+          Utility.asciimath_symbol_object(rparen),
           Utility.unfenced_value(base_value),
           Utility.unfenced_value(power_value),
         )
@@ -558,7 +556,7 @@ module Plurimath
            power_value: simple(:power_value),
            expr: sequence(:expr)) do
         power_base = Math::Function::PowerBase.new(
-          Utility.symbol_object(rparen),
+          Utility.asciimath_symbol_object(rparen),
           Utility.unfenced_value(base_value),
           Utility.unfenced_value(power_value),
         )
@@ -570,7 +568,7 @@ module Plurimath
            power_value: simple(:power_value),
            expr: sequence(:expr)) do
         power_base = Math::Function::PowerBase.new(
-          Utility.symbol_object(rparen),
+          Utility.asciimath_symbol_object(rparen),
           Utility.unfenced_value(base_value),
           Utility.unfenced_value(power_value),
         )
@@ -582,9 +580,9 @@ module Plurimath
            power_value: simple(:power_value),
            comma: simple(:comma),
            expr: sequence(:expr)) do
-        coma = Utility.symbol_object(comma)
+        coma = Utility.asciimath_symbol_object(comma)
         power_base = Math::Function::PowerBase.new(
-          Utility.symbol_object(rparen),
+          Utility.asciimath_symbol_object(rparen),
           Utility.unfenced_value(base_value),
           Utility.unfenced_value(power_value),
         )
@@ -598,9 +596,9 @@ module Plurimath
            power_value: simple(:power_value),
            comma: simple(:comma),
            expr: sequence(:expr)) do
-        coma = Utility.symbol_object(comma)
+        coma = Utility.asciimath_symbol_object(comma)
         power_base = Math::Function::PowerBase.new(
-          Utility.symbol_object(rparen),
+          Utility.asciimath_symbol_object(rparen),
           Utility.unfenced_value(base_value),
           Utility.unfenced_value(power_value),
         )
@@ -656,7 +654,7 @@ module Plurimath
            symbol: simple(:symbol)) do
         [
           sequence,
-          Math::Symbol.new(symbol),
+          Utility.asciimath_symbol_object(symbol),
         ]
       end
 
@@ -671,8 +669,8 @@ module Plurimath
            x: simple(:x)) do
         Math::Formula.new(
           [
-            Utility.symbol_object(d),
-            Utility.symbol_object(x),
+            Utility.asciimath_symbol_object(d),
+            Utility.asciimath_symbol_object(x),
           ],
         )
       end
@@ -695,18 +693,14 @@ module Plurimath
       rule(sequence: simple(:sequence),
            symbol: simple(:sym),
            expr: simple(:expr)) do
-        symbol = Utility.symbol_object(
-          (Constants::SYMBOLS[sym.to_sym] || sym).to_s,
-        )
+        symbol = Utility.asciimath_symbol_object(sym)
         [sequence, symbol, expr]
       end
 
       rule(sequence: simple(:sequence),
            symbol: simple(:sym),
            expr: sequence(:expr)) do
-        symbol = Utility.symbol_object(
-          (Constants::SYMBOLS[sym.to_sym] || sym).to_s,
-        )
+        symbol = Utility.asciimath_symbol_object(sym)
         new_arr = [sequence, symbol]
         new_arr += expr.flatten.compact unless expr.to_s.strip.empty?
         new_arr
@@ -821,9 +815,7 @@ module Plurimath
 
       rule(unary_class: simple(:function),
            symbol: simple(:symbol)) do
-        symbol_object = Utility.symbol_object(
-          (Constants::SYMBOLS[symbol.to_sym] || symbol).to_s,
-        )
+        symbol_object = Utility.asciimath_symbol_object(symbol)
         Utility.get_class(function).new(symbol_object)
       end
 
@@ -887,7 +879,7 @@ module Plurimath
            comma: simple(:comma)) do
         [
           Math::Number.new(number),
-          Utility.symbol_object(comma),
+          Utility.asciimath_symbol_object(comma),
         ]
       end
 
@@ -949,22 +941,20 @@ module Plurimath
                       else
                         [expr]
                       end
-        right_paren = rparen.to_s.empty? ? "" : rparen
         Math::Function::Fenced.new(
-          Utility.symbol_object(lparen),
+          Utility.asciimath_symbol_object(lparen),
           form_value&.flatten&.compact,
-          Utility.symbol_object(right_paren),
+          Utility.asciimath_symbol_object(rparen),
         )
       end
 
       rule(lparen: simple(:lparen),
            expr: sequence(:expr),
            rparen: simple(:rparen)) do
-        right_paren = rparen.to_s.empty? ? "" : rparen
         Math::Function::Fenced.new(
-          Utility.symbol_object(lparen),
+          Utility.asciimath_symbol_object(lparen),
           expr.flatten.compact,
-          Utility.symbol_object(right_paren),
+          Utility.asciimath_symbol_object(rparen),
         )
       end
 
@@ -982,7 +972,7 @@ module Plurimath
 
       rule(color: sequence(:color),
            color_value: sequence(:color_value)) do
-        Utility.symbol_object(color)
+        Utility.asciimath_symbol_object(color)
       end
 
       rule(color: simple(:color),
@@ -1008,7 +998,7 @@ module Plurimath
       rule(color: simple(:color),
            color_value: simple(:color_value)) do
         first_value = if color.is_a?(Math::Function::Text)
-                        Utility.symbol_object(color.parameter_one)
+                        Utility.asciimath_symbol_object(color.parameter_one)
                       else
                         color
                       end
@@ -1025,8 +1015,8 @@ module Plurimath
           [
             table_row,
           ],
-          Utility.symbol_object(table_left).value,
-          Utility.symbol_object(table_right).value,
+          Utility.asciimath_symbol_object(table_left),
+          Utility.asciimath_symbol_object(table_right),
         )
       end
 
@@ -1038,8 +1028,8 @@ module Plurimath
         new_arr << expr unless expr.to_s.strip.empty?
         Math::Function::Table.new(
           new_arr,
-          Utility.symbol_object(table_left).value,
-          Utility.symbol_object(table_right).value,
+          Utility.asciimath_symbol_object(table_left),
+          Utility.asciimath_symbol_object(table_right),
         )
       end
 
@@ -1050,8 +1040,8 @@ module Plurimath
            table_right: simple(:table_right)) do
         table = Math::Function::Table.new(
           [table_row, expr],
-          Utility.symbol_object(table_left).value,
-          Utility.symbol_object(table_right).value,
+          Utility.asciimath_symbol_object(table_left),
+          Utility.asciimath_symbol_object(table_right),
         )
         Math::Function::Norm.new(table)
       end
@@ -1062,8 +1052,8 @@ module Plurimath
            table_right: simple(:table_right)) do
         Math::Function::Table.new(
           expr.flatten.compact.insert(0, table_row),
-          Utility.symbol_object(table_left).value,
-          Utility.symbol_object(table_right).value,
+          Utility.asciimath_symbol_object(table_left),
+          Utility.asciimath_symbol_object(table_right),
         )
       end
 
@@ -1073,8 +1063,8 @@ module Plurimath
            right: simple(:right)) do
         Math::Function::Table.new(
           expr.flatten.compact.insert(0, table_row),
-          Utility.symbol_object(left).value,
-          Utility.symbol_object(right).value,
+          Utility.asciimath_symbol_object(left),
+          Utility.asciimath_symbol_object(right),
         )
       end
     end

data/lib/plurimath/formatter/localized_number.rb

@@ -0,0 +1,13 @@
+module Plurimath
+  module Formatter
+    class LocalizedNumber < TwitterCldr::Localized::LocalizedNumber
+      def to_s(options = {})
+        opts = { type: @type, format: @format }.merge(options)
+
+        NumberDataReader
+          .new(locale, opts)
+          .format_number(base_obj, opts)
+      end
+    end
+  end
+end

data/lib/plurimath/formatter/number_data_reader.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Plurimath
+  module Formatter
+    class NumberDataReader < TwitterCldr::DataReaders::NumberDataReader
+      def formatter
+        NumberFormatter.new(self)
+      end
+    end
+  end
+end

data/lib/plurimath/formatter/number_formatter.rb

@@ -1,113 +1,39 @@
-require "twitter_cldr"
-require_relative "twitter_cldr_rb/integer"
-require_relative "twitter_cldr_rb/fraction"
-require_relative "twitter_cldr_rb/number_formatter"
+# frozen_string_literal: true
 
 module Plurimath
   module Formatter
-    class NumberFormatter
-      attr_accessor :locale, :localize_number, :localizer_symbols
+    class NumberFormatter < TwitterCldr::Formatters::NumberFormatter
+      def format(tokens, number, options = {})
+        options[:precision] ||= precision_from(number)
+        options[:type] ||= :decimal
 
-      LOCALIZE_NUMBER_REGEX = %r{(?<group>[^#])?(?<groupdigits>#+0)(?<decimal>.)(?<fractdigits>#+)(?<fractgroup>[^#])?}
-      SUPPORTED_NOTATIONS = %i[e scientific engineering].freeze
+        prefix, suffix, integer_format, fraction_format = *partition_tokens(tokens)
+        number = truncate_number(number, integer_format.format.length)
 
-      def initialize(locale, localize_number:, localizer_symbols:)
-        @locale = locale
-        @localize_number = localize_number
-        @localizer_symbols = localizer_symbols
-        @twitter_cldr_reader = twitter_cldr_reader(locale)
-      end
-
-      def localized_number(number_string, locale:, precision:, format:)
-        options_instance_variables(number_string, format, precision)
-        @twitter_cldr_reader.merge!(format)
-        return send("#{@notation}_format", number_string) if SUPPORTED_NOTATIONS.include?(@notation&.to_sym)
+        int, fraction = parse_number(number, options)
+        result = integer_format.apply(int, options)
+        result << fraction_format.apply(fraction, options, int) if fraction
 
-        localize_number(number_string)
+        number_system.transliterate(
+          "#{prefix.to_s}#{result}#{suffix.to_s}"
+        )
       end
 
       private
 
-      def twitter_cldr_reader(locale)
-        num = TwitterCldr::DataReaders::NumberDataReader.new(locale)
-        num.symbols
-          .merge!(@localizer_symbols)
-          .merge!(parse_localize_number)
-      end
-
-      def parse_localize_number
-        @localize_number or return {}
-        m = LOCALIZE_NUMBER_REGEX.match(@localize_number) or return {}
-        ret = {
-          decimal: m[:decimal],
-          group_digits: m[:groupdigits].size,
-          fraction_group_digits: m[:fractdigits].size,
-          group: m[:group] == " " ? "\u00A0" : (m[:group] || ""),
-          fraction_group: m[:fractgroup] == " " ? "\u00A0" : (m[:fractgroup]  || "")
-        }.compact
-      end
-
-      def localize_number(num)
-        num = num.match?(/\./) ? num.to_f : num.to_i
-        localized = BigDecimal(num.to_s).localize(@locale)
-        return localized.to_s if @precision.zero?
-
-        localized.to_decimal.to_s(precision: @precision)
-      end
-
-      def e_format(num_str)
-        notations_formatting(num_str).join(@e.to_s)
-      end
-
-      def scientific_format(num_str)
-        notations_formatting(num_str).join(" #{@times} 10^")
-      end
-
-      def engineering_format(num_str)
-        @precision = num_str.length - 1 unless @precision > 0
-        chars = notation_chars(num_str)
-        update_string_index(chars, chars.last.to_i % 3)
-        chars[0] = localize_number(chars[0])
-        chars.join(" #{@times} 10^")
-      end
-
-      def update_exponent_sign(str)
-        str.gsub!("e", "e+") if @exponent_sign == :plus
-      end
-
-      def notation_chars(num_str)
-        notation_number = ("%.#{@precision}e" %num_str)
-        update_exponent_sign(notation_number.gsub!("+0", ""))
-        notation_number.split("e")
-      end
-
-      def notations_formatting(num_str)
-        chars = notation_chars(num_str)
-        chars[0] = localize_number(chars[0])
-        chars
-      end
-
-      def options_instance_variables(string, format, precision)
-        @e = format.delete(:e)&.to_sym || :e
-        @times = format.delete(:times)&.to_sym || "\u{d7}"
-        @notation = format.delete(:notation)&.to_sym || nil
-        @precision = update_precision(string, precision)
-        @exponent_sign = format.delete(:exponent_sign)&.to_sym || nil
-      end
-
-      def update_precision(num, precision)
-        return precision if precision
-        return num.sub(/\./, "").size - 1 if SUPPORTED_NOTATIONS.include?(@notation&.to_sym)
-
-        /\./.match?(num) ? num.sub(/^.*\./, "").size : 0
-      end
-
-      def update_string_index(chars, index)
-        return if index.zero?
-
-        chars.first.delete!(".")
-        chars.first.insert(index + 1, ".")
-        chars[-1] = (chars[-1].to_i - index).to_s
+      def partition_tokens(tokens)
+        [
+          token_val_from(tokens[0]),
+          token_val_from(tokens[2]),
+          Numbers::Integer.new(
+            tokens[1],
+            data_reader.symbols
+          ),
+          Numbers::Fraction.new(
+            tokens[1],
+            data_reader.symbols
+          )
+        ]
       end
     end
   end

data/lib/plurimath/formatter/{twitter_cldr_rb → numbers}/fraction.rb

@@ -1,16 +1,16 @@
 # frozen_string_literal: true
 
-module TwitterCldr
-  module Formatters
+module Plurimath
+  module Formatter
     module Numbers
-      class Fraction
+      class Fraction < TwitterCldr::Formatters::Numbers::Fraction
         attr_reader :format, :decimal, :precision, :separator, :group
 
         def initialize(token, symbols = {})
           @format  = token ? token.value.split('.').pop : ''
           @decimal = symbols[:decimal] || '.'
-          @separator = symbols[:fraction_group] || " "
-          @group = symbols[:fraction_group_digits] || 3
+          @separator = symbols[:fraction_group].to_s
+          @group = symbols[:fraction_group_digits]
           @digit_count = symbols[:digit_count] || nil
           @precision = @format.length
         end
@@ -21,7 +21,8 @@ module TwitterCldr
 
           number = interpolate(format(options), fraction, :left)
           number = digit_count_format(int, fraction, number) if @digit_count
-          decimal + change_format(precision, number)
+          formatted_number = change_format(precision, number) if number
+          formatted_number ? decimal + formatted_number : ""
         end
 
         def format(options)
@@ -33,7 +34,7 @@ module TwitterCldr
 
         def change_format(precision, string)
           tokens = []
-          tokens << string&.slice!(0, group) until string&.empty?
+          tokens << string&.slice!(0, (group || string.length)) until string&.empty?
           tokens.compact.join(separator)
         end
 
@@ -43,7 +44,8 @@ module TwitterCldr
           int_length = integer.length - 1
           @digit_count ||= int_length
           if int_length > @digit_count
-            float.round(@digit_count - int.length).to_s.split(".").last
+            number_string = float.round(@digit_count - int.length)
+            number_string.is_a?(Float) ? number_string.to_s.split(".").last : nil
           elsif int_length < @digit_count
             number += "0" * (@digit_count - int_length)
           end
@@ -52,4 +54,3 @@ module TwitterCldr
     end
   end
 end
-

data/lib/plurimath/formatter/{twitter_cldr_rb → numbers}/integer.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-module TwitterCldr
-  module Formatters
+module Plurimath
+  module Formatter
     module Numbers
-      class Integer
+      class Integer < TwitterCldr::Formatters::Numbers::Integer
         def initialize(token, symbols = {})
           format     = token.value.split('.')[0]
           @format    = prepare_format(format, symbols)