plurimath 0.8.13 → 0.8.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cd471ff00338f1235d74433502b5589c0b95287f196c0088be89cbc91e65a456
-  data.tar.gz: 3f30ce7bd235c3e9c07768240ffafea84e93f63c0da3ae442b2687ad7b2b7f95
+  metadata.gz: 1783cc0eadbbb06f0f9f8cf7ec7c1c67151ae7c85e5a8f6bd8d4f325a2823fc7
+  data.tar.gz: 8f59467437e61ab7e53d828256967f014eed2417400f6df29d3a9a037b7f9545
 SHA512:
-  metadata.gz: 83007b138c9c86561350991289d7007d42b7aa24859f8039c961c7e2434f1f1b381d3e4f85f897bc3c5c1b1f4d22cb4ddf7257bb9f136a0c465695995ba72690
-  data.tar.gz: 6b019a7ed611f78e28c0e62473b4e8ee0780568de8b304fed12f9957fde6aebc7f88f30c4656ddd6500f7ef298462616d5fba6fd6d2e9fc3b03f24be1ef8fde4
+  metadata.gz: 91199c6a3c324fd5ac78147c402ba60ff1dc972d4f99dd33006230700f0b9aa07042e38f677f8440a6873663e977c1c0f9c6db09ce04dac1206535f99cdc43da
+  data.tar.gz: f21bffba36efc43968174c803319992edde54f4cf64e9dc840d5fa7fe9637898c01068d30021b933972ce349615d82ca477dd79ff63142178bd981feb8c09fd5

data/Rakefile

@@ -30,11 +30,10 @@ def write_doc_file(doc_file, type:)
   File.open(doc_file, "a") do |file|
     file.write(file_header)
 
-    Plurimath::Utility.send(:"#{type}_files").each do |symbol|
-      file_name = File.basename(symbol, ".rb")
-      klass = Plurimath::Utility.get_symbol_class(file_name)
+    Plurimath::Utility.send(:"#{type}_files").each do |klass|
       next if klass::INPUT.empty?
-
+      
+      file_name = File.basename(klass.const_source_location(:INPUT).first, ".rb")
       file.write(documentation_content(file_name, klass))
     end
 

data/lib/plurimath/formatter/number_formatter.rb

@@ -2,44 +2,70 @@
 
 module Plurimath
   module Formatter
-    class NumberFormatter < TwitterCldr::Formatters::NumberFormatter
-      def format(tokens, number, options = {})
-        options[:precision] ||= precision_from(number)
-        options[:type] ||= :decimal
+    class NumberFormatter
+      attr_reader :number, :data_reader
 
-        prefix, suffix, integer_format, fraction_format, signif_format = *partition_tokens(tokens)
-        number = truncate_number(number, integer_format.format.length)
+      STRING_SYMBOLS = {
+        dot: ".".freeze,
+        f: "F".freeze,
+      }.freeze
 
-        int, fraction = parse_number(number, options)
-        result = integer_format.apply(int, options)
-        result << fraction_format.apply(fraction, options, int) if fraction
+      def initialize(number, data_reader = {})
+        @number = number
+        @data_reader = data_reader
+      end
+
+      def format(precision: nil)
+        data_reader[:precision] = precision || precision_from(number)
+        int, frac, integer_format, fraction_format, signif_format = *partition_tokens(number)
+        result = integer_format.apply(int, data_reader)
+        result << fraction_format.apply(frac, data_reader, int) if frac
 
         result = signif_format.apply(result, integer_format, fraction_format)
 
-        number_system.transliterate(
-          "#{prefix.to_s}#{result}#{suffix.to_s}"
-        )
+        result
       end
 
       private
 
-      def partition_tokens(tokens)
+      def partition_tokens(number)
+        int, fraction = parse_number(number, data_reader)
         [
-          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
-          ),
-          Numbers::Significant.new(
-            data_reader.symbols,
-          )
+          int,
+          fraction,
+          Numbers::Integer.new(data_reader),
+          Numbers::Fraction.new(data_reader),
+          Numbers::Significant.new(data_reader),
         ]
       end
+
+      def precision_from(number)
+        return 0 if number.fix == number
+
+        parts = number.to_s(STRING_SYMBOLS[:f]).split(STRING_SYMBOLS[:dot])
+        parts.size == 2 ? parts[1].size : 0
+      end
+
+      def parse_number(number, options = {})
+        precision = options[:precision] || precision_from(number)
+
+        num = if precision == 0
+                round_to(number, precision).abs.fix.to_s(STRING_SYMBOLS[:f])
+              else
+                round_to(number, precision).abs.round(precision).to_s(STRING_SYMBOLS[:f])
+              end
+        num.split(STRING_SYMBOLS[:dot])
+      end
+
+      def round_to(number, precision)
+        factor = 10 ** precision
+        result = if number.is_a?(BigDecimal)
+                   ((number * factor).fix / factor)
+                 else
+                   ((number * factor).round.to_f / factor)
+                 end
+        result
+      end
     end
   end
 end

data/lib/plurimath/formatter/numbers/base.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Plurimath
+  module Formatter
+    module Numbers
+      class Base
+        def interpolate(string, value, orientation = :right)
+          value  = value.to_s
+          length = value.length
+          start  = orientation == :left ? 0 : -length
+
+          string = string.dup
+          string = string.ljust(length, '#') if string.length < length
+          string[start, length] = value
+          string.gsub('#', '')
+        end
+      end
+    end
+  end
+end

data/lib/plurimath/formatter/numbers/fraction.rb

@@ -3,20 +3,19 @@
 module Plurimath
   module Formatter
     module Numbers
-      class Fraction < TwitterCldr::Formatters::Numbers::Fraction
-        attr_reader :format, :decimal, :precision, :separator, :group
+      class Fraction < Base
+        attr_reader :decimal, :precision, :separator, :group
 
-        def initialize(token, symbols = {})
-          @format  = token ? token.value.split('.').pop : ''
+        def initialize(symbols = {})
+          @precision = 3
           @decimal = symbols[:decimal] || '.'
           @separator = symbols[:fraction_group].to_s
           @group = symbols[:fraction_group_digits]
           @digit_count = symbols[:digit_count] || nil
-          @precision = @format.length
         end
 
         def apply(fraction, options = {}, int = "")
-          precision = options[:precision] || self.precision
+          precision = options[:precision] || @precision
           return "" unless precision > 0
 
           number = interpolate(format(options), fraction, :left)
@@ -26,7 +25,7 @@ module Plurimath
         end
 
         def format(options)
-          precision = options[:precision] || self.precision
+          precision = options[:precision] || @precision
           precision ? '0' * precision : @format
         end
 
@@ -66,13 +65,13 @@ module Plurimath
         end
 
         def update_digit_count(number)
-          return @digit_count unless all_zeros?(number) == @precision
+          return @digit_count unless zeros_count_in(number) == @precision
 
           @digit_count - @precision + 1
         end
 
-        def all_zeros?(number)
-          return unless number.split('').all? { |dig| dig == "0" }
+        def zeros_count_in(number)
+          return unless number.split('').all? { |digit| digit == "0" }
 
           number.length
         end

data/lib/plurimath/formatter/numbers/integer.rb

@@ -3,13 +3,32 @@
 module Plurimath
   module Formatter
     module Numbers
-      class Integer < TwitterCldr::Formatters::Numbers::Integer
-        def initialize(token, symbols = {})
-          format     = token.value.split('.')[0]
-          @format    = prepare_format(format, symbols)
-          @groups    = Array(symbols[:group_digits] || parse_groups(format))
+      class Integer < Base
+        attr_reader :format, :separator, :groups
+
+        def initialize(symbols = {})
+          @groups    = Array(symbols[:group_digits] || 3)
           @separator = symbols[:group] || ','
         end
+
+        def apply(number, options = {})
+          format_groups(interpolate(number, number.to_i))
+        end
+
+        def format_groups(string)
+          return string if groups.empty?
+
+          tokens = []
+
+          tokens << chop_group(string, groups.first)
+          tokens << chop_group(string, groups.last) until string.empty?
+
+          tokens.compact.reverse.join(separator)
+        end
+
+        def chop_group(string, size)
+          string.slice!([string.size - size, 0].max, size)
+        end
       end
     end
   end

data/lib/plurimath/formatter/numeric_formatter.rb

@@ -1,10 +1,9 @@
-require "twitter_cldr"
+require_relative "supported_locales"
+require_relative "numbers/base"
 require_relative "numbers/integer"
 require_relative "numbers/fraction"
 require_relative "numbers/significant"
 require_relative "number_formatter"
-require_relative "number_data_reader"
-require_relative "localized_number"
 
 module Plurimath
   module Formatter
@@ -32,8 +31,8 @@ module Plurimath
       private
 
       def twitter_cldr_reader_lookup
-        num = TwitterCldr::DataReaders::NumberDataReader.new(locale)
-        num.symbols
+        symbols = Formatter::SupportedLocales::LOCALES[locale.to_sym]
+        symbols
           .merge!(@localizer_symbols)
           .merge!(parse_localize_number)
       end
@@ -51,10 +50,12 @@ module Plurimath
       end
 
       def localize_number(num)
-        localized = localize(BigDecimal(num.to_s))
-        return localized.to_s if @precision.zero?
-
-        localized.to_decimal.to_s(precision: @precision)
+        Formatter::NumberFormatter.new(
+          BigDecimal(num),
+          @twitter_cldr_reader,
+        ).format(
+          precision: @precision
+        )
       end
 
       def e_format(num_str)
@@ -74,10 +75,6 @@ module Plurimath
         chars.join(" #{@times} 10^")
       end
 
-      def update_exponent_sign(str)
-        str.gsub!("e", "e+") if @exponent_sign == :plus
-      end
-
       def update_exponent_value(number_str)
         exponent_number = BigDecimal(number_str) - 1
         "#{"+" if @exponent_sign == :plus}#{exponent_number.to_i}"
@@ -87,9 +84,9 @@ module Plurimath
         notation_array = BigDecimal(num_str).to_s("e").split("e")
         notation_array[1] = update_exponent_value(notation_array[1])
         number_str = notation_array[0]
-        number_str.gsub!(/0\.(\d)/, '\1.')
-        number_str.sub!('.', '') if number_str.start_with?(".")
-        notation_array[0] = number_str[0..-2] if number_str.end_with?(".")
+        number_str = number_str.gsub(/0\.(\d)/, '\1.')
+        number_str = number_str.sub('.', '') if number_str.start_with?(".")
+        notation_array[0] = number_str.end_with?(".") ? number_str[0..-2] : number_str
         notation_array
       end
 
@@ -122,10 +119,6 @@ module Plurimath
         chars.first.insert(index + 1, ".") unless chars.first[index + 2].nil?
         chars[-1] = (chars[-1].to_i - index).to_s
       end
-
-      def localize(value)
-        LocalizedNumber.new(value, @locale, type: :decimal)
-      end
     end
   end
 end

data/lib/plurimath/formatter/standard.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative "../number_formatter"
+module Plurimath
+  module Formatter
+    class Standard < Plurimath::NumberFormatter
+      attr_accessor :precision
+
+      DEFAULT_OPTIONS = {
+        fraction_group_digits: 3,
+        exponent_sign: "plus",
+        fraction_group: "'",
+        notation: :basic,
+        group_digits: 3,
+        significant: 0,
+        digit_count: 0,
+        decimal: ".",
+        group: ",",
+        times: "x",
+        e: "e",
+      }.freeze
+
+      def initialize(locale: "en", string_format: nil, options: {}, precision: nil)
+        @precision = precision
+        super(
+          locale,
+          localize_number: string_format,
+          localizer_symbols: set_default_options(options),
+        )
+      end
+
+      def set_default_options(options)
+        default_options = self.class::DEFAULT_OPTIONS
+        options ||= default_options
+        options[:fraction_group_digits] ||= default_options[:fraction_group_digits]
+        options[:fraction_group] ||= default_options[:fraction_group]
+        options[:exponent_sign] ||= default_options[:exponent_sign]
+        options[:group_digits] ||= default_options[:group_digits]
+        options[:significant] ||= default_options[:significant]
+        options[:notation] ||= default_options[:notation]
+        options[:decimal] ||= default_options[:decimal]
+        options[:group] ||= default_options[:group]
+        options[:times] ||= default_options[:times]
+        options[:e] ||= default_options[:e]
+        options
+      end
+    end
+  end
+end

data/lib/plurimath/formatter/supported_locales.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Plurimath
+  module Formatter
+    class SupportedLocales
+      LOCALES = {
+        "sr-Cyrl-ME": { decimal: ",", group: "." },
+        "sr-Latn-ME": { decimal: ",", group: "." },
+        "zh-Hant": { decimal: ".", group: "," },
+        "en-001": { decimal: ".", group: "," },
+        "en-150": { decimal: ".", group: "," },
+        "pt-PT": { decimal: ",", group: " " },
+        "nl-BE": { decimal: ",", group: "." },
+        "it-CH": { decimal: ".", group: "’" },
+        "fr-BE": { decimal: ",", group: " " },
+        "fr-CA": { decimal: ",", group: " " },
+        "fr-CH": { decimal: ",", group: " " },
+        "de-AT": { decimal: ",", group: " " },
+        "de-CH": { decimal: ".", group: "’" },
+        "en-AU": { decimal: ".", group: "," },
+        "en-CA": { decimal: ".", group: "," },
+        "en-GB": { decimal: ".", group: "," },
+        "en-IE": { decimal: ".", group: "," },
+        "en-IN": { decimal: ".", group: "," },
+        "en-NZ": { decimal: ".", group: "," },
+        "en-SG": { decimal: ".", group: "," },
+        "en-US": { decimal: ".", group: "," },
+        "en-ZA": { decimal: ".", group: "," },
+        "es-419": { decimal: ".", group: "," },
+        "es-AR": { decimal: ",", group: "." },
+        "es-CO": { decimal: ",", group: "." },
+        "es-MX": { decimal: ".", group: "," },
+        "es-US": { decimal: ".", group: "," },
+        fil: { decimal: ".", group: "," },
+        af: { decimal: ",", group: " " },
+        ar: { decimal: "٫", group: "٬" },
+        az: { decimal: ",", group: "." },
+        be: { decimal: ",", group: " " },
+        bg: { decimal: ",", group: " " },
+        bn: { decimal: ".", group: "," },
+        bo: { decimal: ".", group: "," },
+        bs: { decimal: ",", group: "." },
+        ca: { decimal: ",", group: "." },
+        cs: { decimal: ",", group: " " },
+        cy: { decimal: ".", group: "," },
+        da: { decimal: ",", group: "." },
+        de: { decimal: ",", group: "." },
+        el: { decimal: ",", group: "." },
+        en: { decimal: ".", group: "," },
+        eo: { decimal: ",", group: " " },
+        es: { decimal: ",", group: "." },
+        et: { decimal: ",", group: " " },
+        eu: { decimal: ",", group: "." },
+        fa: { decimal: "٫", group: "٬" },
+        fi: { decimal: ",", group: " " },
+        fr: { decimal: ",", group: " " },
+        ga: { decimal: ".", group: "," },
+        gl: { decimal: ",", group: "." },
+        gu: { decimal: ".", group: "," },
+        he: { decimal: ".", group: "," },
+        hi: { decimal: ".", group: "," },
+        hr: { decimal: ",", group: "." },
+        hu: { decimal: ",", group: " " },
+        hy: { decimal: ",", group: " " },
+        id: { decimal: ",", group: "." },
+        is: { decimal: ",", group: "." },
+        it: { decimal: ",", group: "." },
+        ja: { decimal: ".", group: "," },
+        ka: { decimal: ",", group: " " },
+        kk: { decimal: ",", group: " " },
+        km: { decimal: ",", group: "." },
+        kn: { decimal: ".", group: "," },
+        ko: { decimal: ".", group: "," },
+        lo: { decimal: ",", group: "." },
+        lt: { decimal: ",", group: " " },
+        lv: { decimal: ",", group: " " },
+        mk: { decimal: ",", group: "." },
+        mr: { decimal: ".", group: "," },
+        ms: { decimal: ".", group: "," },
+        mt: { decimal: ".", group: "," },
+        my: { decimal: ".", group: "," },
+        nb: { decimal: ",", group: " " },
+        nl: { decimal: ",", group: "." },
+        pl: { decimal: ",", group: " " },
+        pt: { decimal: ",", group: "." },
+        ro: { decimal: ",", group: "." },
+        ru: { decimal: ",", group: " " },
+        sk: { decimal: ",", group: " " },
+        sl: { decimal: ",", group: "." },
+        sq: { decimal: ",", group: " " },
+        sr: { decimal: ",", group: "." },
+        sv: { decimal: ",", group: " " },
+        sw: { decimal: ".", group: "," },
+        ta: { decimal: ".", group: "," },
+        th: { decimal: ".", group: "," },
+        tr: { decimal: ",", group: "." },
+        uk: { decimal: ",", group: " " },
+        ur: { decimal: ".", group: "," },
+        vi: { decimal: ",", group: "." },
+        xh: { decimal: ".", group: " " },
+        zh: { decimal: ".", group: "," },
+        zu: { decimal: ".", group: "," },
+      }
+    end
+  end
+end

data/lib/plurimath/html/parse.rb

@@ -4,6 +4,7 @@ require "parslet"
 module Plurimath
   class Html
     class Parse < Parslet::Parser
+      rule(:space)   { match["\s"].repeat(1) }
       rule(:unary)   { array_to_expression(Constants::UNARY_CLASSES, :unary) }
       rule(:binary)  { str("lim").as(:binary) }
       rule(:sub_tag) { parse_sub_sup_tags("sub") }
@@ -74,9 +75,10 @@ module Plurimath
       rule(:symbol_text_or_tag) do
         tag_parse |
           (str("&") >> match["a-zA-Z0-9"].repeat(2) >> str(";")).as(:symbol) |
-          match["0-9"].as(:number) |
+          (match["0-9"].repeat(1) >> str(".") >> match["0-9"].repeat(1)).as(:number) |
+          match["0-9"].repeat(1).as(:number) |
           match["a-zA-Z"].as(:text) |
-          match["^0-9a-zA-Z<>/(){}\\[\\]"].as(:symbol)
+          match["^0-9a-zA-Z<>/(){}\\[\\]\s"].as(:symbol)
       end
 
       rule(:intermediate_exp) do
@@ -84,7 +86,8 @@ module Plurimath
           (symbol_text_or_tag.as(:sub_sup) >> sub_sup_tags) |
           sub_sup |
           parse_classes |
-          symbol_text_or_tag
+          symbol_text_or_tag |
+          space
       end
 
       rule(:parse_parenthesis) do

data/lib/plurimath/html/parser.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "json"
+require "cgi"
 require_relative "parse"
 require_relative "constants"
 require_relative "transform"
@@ -10,7 +11,7 @@ module Plurimath
       attr_accessor :text
 
       def initialize(text)
-        @text = CGI.unescapeHTML(text)
+        @text = ::CGI.unescapeHTML(text)
       end
 
       def parse