asciimath 2.0.1 → 2.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d4492ccf2978a02b79bf6d5a70a23871fd33db6893e4a90b1b159db3b4d7b8b3
-  data.tar.gz: 43fbc1d2bba388ca359e0e908e0118b22189479cc05bf4a9882cb6459b4c6488
+  metadata.gz: 6c38e7e41750527b0992c27f6e636cb6b670eec3008563e1a5fe19fc86458991
+  data.tar.gz: 3313df7a9524d4a4e384be1ec54f38aafe2ff70553ae65aa695c530fff5f45e9
 SHA512:
-  metadata.gz: 60c01de3ce18dd8eec2ff1a1fa559da2e0de840e08b59686ab3d1ff913a02f2656f2d8ceee1106657ae99bf9de2fdb2f80eeef1f71cc604845541d9d503f7bed
-  data.tar.gz: 62e0c29f76f709c53b040260dee1e36dce9af4c8737822297ea9d1908b2c72ade763d236c36266c411ce8f7330fbf397d4f0877ac2d5fc80d9064c40920bcbee
+  metadata.gz: a7b29b1332ddb6965162a5b1e82d15c459e5a9ea4d514646b0663ea52adfe5b1999d1078e850dee228160e09b5ac052dde48b39aaa946d6587b97b2658109215
+  data.tar.gz: 6bfce3c229fea323dbfaff74ab1987802b9ae6c7b0ae32562b868bc5da2fd35bc76d0a8c9aa1e414c2765839e02065c5575d5366af89e4becadb882ee084ce08

data/.github/workflows/ci.yml

@@ -0,0 +1,20 @@
+name: CI
+on: [push, pull_request]
+jobs:
+  test:
+    strategy:
+      matrix:
+        ruby: [jruby, 2.3, 2.4, 2.5, 2.6, 2.7]
+        os: [ubuntu-latest, macos-latest, windows-latest]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+      - name: Build
+        run: bundle install --jobs 4 --retry 3
+      - name: Test
+        run: bundle exec rake test

data/AST.adoc

@@ -257,8 +257,8 @@ Empty matrix cells are represented as `AsciiMath::AST::Empty`.
 |++oo++ |:infty |++∞++ (https://codepoints.net/U+221E[U+221E]) |++\infty++
 |++infty++ |:infty |++∞++ (https://codepoints.net/U+221E[U+221E]) |++\infty++
 |++aleph++ |:aleph |++ℵ++ (https://codepoints.net/U+2135[U+2135]) |++\aleph++
-|++...++ |:ellipsis |++…++ (https://codepoints.net/U+2026[U+2026]) |++\ellipsis++
-|++ldots++ |:ellipsis |++…++ (https://codepoints.net/U+2026[U+2026]) |++\ellipsis++
+|++...++ |:ellipsis |++…++ (https://codepoints.net/U+2026[U+2026]) |++\ldots++
+|++ldots++ |:ellipsis |++…++ (https://codepoints.net/U+2026[U+2026]) |++\ldots++
 |++:.++ |:therefore |++∴++ (https://codepoints.net/U+2234[U+2234]) |++\therefore++
 |++therefore++ |:therefore |++∴++ (https://codepoints.net/U+2234[U+2234]) |++\therefore++
 |++:'++ |:because |++∵++ (https://codepoints.net/U+2235[U+2235]) |++\because++

data/CHANGELOG.adoc

@@ -1,5 +1,36 @@
 = Asciimath Changelog
 
+== 2.0.4
+
+Bug fixes::
+
+  * Issue #69: correctly render sub and superscripts as following `obrace` and `ubrace`.
+  * Issue #70: fix MathML output for `frac`.
+  * Issue #71: correctly parse row vectors.
+
+== 2.0.3
+
+Enhancements::
+
+  * Issue #59: make escaping of non-ASCII characters in MathML and HTML output optional.
+
+Bug fixes::
+
+  * Issue #58: produce `<mo>` tags instead of `<mi>` tags for non-alphanumeric strings.
+  * Issue #62: resolve infinite recursion in LaTeX generator.
+
+== 2.0.2
+
+Enhancements::
+
+  * Issue #51: generate `accent` and `accentunder` attributes on `munder`, `mover`, and `munderover` tags when appropriate
+  * Issue #52: map `phi` to U+03D5 and `varphi` to U+03C6 by default.
+  * Issue #53: Add support for Roman style font command `rm`.
+
+Bug fixes::
+
+  * Issue #50: fix parsing error when unary and binary operators are missing an operand
+
 == 2.0.1
 
 Enhancements::

data/Gemfile

@@ -2,3 +2,8 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in asciimath.gemspec
 gemspec
+
+gem "bundler", "> 0"
+gem "rake", "~> 13.0.0"
+gem "rspec", "~> 3.9.0"
+gem "nokogiri"

data/README.adoc

@@ -1,4 +1,5 @@
 # AsciiMath
+:uri-project: https://github.com/asciidoctor/asciimath
 ifndef::env-site[:status:]
 
 An http://asciimath.org[AsciiMath] parser and MathML/LaTeX generator written in pure Ruby.
@@ -7,7 +8,7 @@ ifdef::status[]
 [discrete]
 ## Status
 
-image:https://travis-ci.org/pepijnve/asciimath.svg?branch=master["Linux Build Status", link="https://travis-ci.org/asciidoctor/asciimath"]
+image:{uri-project}/workflows/CI/badge.svg?branch=master["Build Status", link={uri-project}/actions?query=branch%3Amaster]
 image:https://img.shields.io/gem/v/asciimath.svg?label=gem%20version[Gem Version, link=https://rubygems.org/gems/asciimath]
 endif::status[]
 

data/asciimath.gemspec

@@ -18,9 +18,4 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
-
-  spec.add_development_dependency "bundler", "> 0"
-  spec.add_development_dependency "rake", "~> 13.0.0"
-  spec.add_development_dependency "rspec", "~> 3.9.0"
-  spec.add_development_dependency "nokogiri", "~> 1.10.9"
 end

data/dump_symbol_table.rb

@@ -21,7 +21,7 @@ AsciiMath::Parser::DEFAULT_PARSER_SYMBOL_TABLE.each_pair do |asciimath, value|
     next
   end
 
-  mathml = AsciiMath::MathMLBuilder::DEFAULT_DISPLAY_SYMBOL_TABLE[sym]
+  mathml = AsciiMath::MathMLBuilder.default_display_symbol_table[sym]
 
   if mathml
     val = mathml[:value]

data/lib/asciimath/ast.rb

@@ -51,8 +51,8 @@ module AsciiMath
       Number.new(value)
     end
 
-    def symbol(symbol, text)
-      Symbol.new(symbol, text)
+    def symbol(symbol, text, type)
+      Symbol.new(symbol, text, type)
     end
 
     def identifier(value)
@@ -340,14 +340,16 @@ module AsciiMath
 
     class Symbol < ValueNode
       attr_reader :text
+      attr_reader :type
 
-      def initialize(value, text)
+      def initialize(value, text, type)
         super(value)
         @text = text.dup.freeze
+        @type = type
       end
 
       def ==(o)
-        super && o.text == text
+        super && o.text == text && o.type == type
       end
 
       def to_s

data/lib/asciimath/html.rb

@@ -4,9 +4,10 @@ module AsciiMath
   class HTMLBuilder < ::AsciiMath::MarkupBuilder
 
     def initialize(opts = {})
-      super(opts[:symbol_table] || DEFAULT_DISPLAY_SYMBOL_TABLE)
+      super(opts[:symbol_table] || ::AsciiMath::MarkupBuilder.default_display_symbol_table(fix_phi: opts.fetch(:fix_phi, true)))
       @prefix = opts[:prefifx] || ''
       @inline = opts[:inline]
+      @escape_non_ascii = opts.fetch(:escape_non_ascii, true)
       @html = ''
     end
 
@@ -227,7 +228,7 @@ module AsciiMath
             @html << "&lt;"
           elsif cp == 62
             @html << "&gt;"
-          elsif cp > 127
+          elsif cp > 127 && @escape_non_ascii
             @html << "&#x#{cp.to_s(16).upcase};"
           else
             @html << cp

data/lib/asciimath/latex.rb

@@ -27,7 +27,9 @@ module AsciiMath
       :ne => "\\neq",
       :assign => ":=",
       :lt => ?<,
+      :mlt => "\\ll",
       :gt => ?>,
+      :mgt => "\\gg",
       :sub => "\\text{–}",
       :sup => "\\text{^}",
       :implies => "\\Rightarrow",
@@ -83,6 +85,7 @@ module AsciiMath
       :f => "f",
       :g => "g",
       :to => "\\rightarrow",
+      :ellipsis => "\\ldots",
       :bold => "\\mathbf",
       :double_struck => "\\mathbb",
       :italic => "\\mathit",
@@ -96,6 +99,7 @@ module AsciiMath
       :bold_sans_serif => "\\mathsf",
       :sans_serif_italic => "\\mathsf",
       :sans_serif_bold_italic => "\\mathsf",
+      :roman => "\\mathrm",
     }.freeze
 
     private
@@ -165,7 +169,12 @@ module AsciiMath
           sup = expression.sup_expression
           e = expression.base_expression
 
+          if e.is_a?(AsciiMath::AST::UnaryOp) &&
+            %i[underbrace overbrace].include?(e.operator.value)
+            append(e)
+        else
           curly(e)
+        end
 
           if sub
             @latex << "_"
@@ -244,8 +253,6 @@ module AsciiMath
           end
         
         when AsciiMath::AST::Matrix
-          len = expression.length - 1
-          
           parens(expression.lparen, expression.rparen) do
             c = expression.length
             @latex << "\\begin{matrix} "
@@ -383,7 +390,7 @@ module AsciiMath
       when AsciiMath::AST::Group
         is_very_small(e.expression)
       when AsciiMath::AST::Sequence
-        e.all? { |s| is_very_small(e) }
+        e.all? { |s| is_very_small(s) }
       when nil
         true
       else

data/lib/asciimath/markup.rb

@@ -4,7 +4,7 @@ require_relative 'symbol_table'
 module AsciiMath
   class MarkupBuilder
     # Operation symbols
-    def self.add_default_display_symbols(b)
+    def self.add_default_display_symbols(b, fix_phi: true)
       b.add(:plus, '+', :operator)
       b.add(:minus, "\u2212", :operator)
       b.add(:cdot, "\u22C5", :operator)
@@ -38,7 +38,9 @@ module AsciiMath
       b.add(:ne, "\u2260", :operator)
       b.add(:assign, "\u2254", :operator)
       b.add(:lt, "\u003C", :operator)
+      b.add(:mlt, "\u226A", :operator)
       b.add(:gt, "\u003E", :operator)
+      b.add(:mgt, "\u226B", :operator)
       b.add(:le, "\u2264", :operator)
       b.add(:ge, "\u2265", :operator)
       b.add(:prec, "\u227A", :operator)
@@ -52,6 +54,7 @@ module AsciiMath
       b.add(:subseteq, "\u2286", :operator)
       b.add(:supseteq, "\u2287", :operator)
       b.add(:equiv, "\u2261", :operator)
+      b.add(:sim, "\u223C", :operator)
       b.add(:cong, "\u2245", :operator)
       b.add(:approx, "\u2248", :operator)
       b.add(:propto, "\u221D", :operator)
@@ -92,6 +95,7 @@ module AsciiMath
       b.add(:partial, "\u2202", :operator)
       b.add(:nabla, "\u2207", :operator)
       b.add(:pm, "\u00B1", :operator)
+      b.add(:mp, "\u2213", :operator)
       b.add(:emptyset, "\u2205", :operator)
       b.add(:infty, "\u221E", :operator)
       b.add(:aleph, "\u2135", :operator)
@@ -206,8 +210,8 @@ module AsciiMath
       b.add(:ddot, '..', :accent, :position => :over)
       b.add(:overarc, "\u23DC", :accent, :position => :over)
       b.add(:underline, '_', :accent, :position => :under)
-      b.add(:underbrace, "\u23DF", :accent, :position => :under)
-      b.add(:overbrace, "\u23DE", :accent, :position => :over)
+      b.add(:underbrace, "\u23DF", :accent, :position => :under, :underover => true)
+      b.add(:overbrace, "\u23DE", :accent, :position => :over, :underover => true)
       b.add(:bold, :bold, :font)
       b.add(:double_struck, :double_struck, :font)
       b.add(:italic, :italic, :font)
@@ -221,6 +225,7 @@ module AsciiMath
       b.add(:bold_sans_serif, :bold_sans_serif, :font)
       b.add(:sans_serif_italic, :sans_serif_italic, :font)
       b.add(:sans_serif_bold_italic, :sans_serif_bold_italic, :font)
+      b.add(:roman, :normal, :font)
 
       # Greek letters
       b.add(:alpha, "\u03b1", :identifier)
@@ -265,9 +270,14 @@ module AsciiMath
       b.add(:Tau, "\u03a4", :identifier)
       b.add(:upsilon, "\u03c5", :identifier)
       b.add(:Upsilon, "\u03a5", :identifier)
-      b.add(:phi, "\u03c6", :identifier)
+      if fix_phi
+        b.add(:phi, "\u03d5", :identifier)
+        b.add(:varphi, "\u03c6", :identifier)
+      else
+        b.add(:phi, "\u03c6", :identifier)
+        b.add(:varphi, "\u03d5", :identifier)
+      end
       b.add(:Phi, "\u03a6", :identifier)
-      b.add(:varphi, "\u03d5", :identifier)
       b.add(:chi, "\u03c7", :identifier)
       b.add(:Chi, "\u03a7", :identifier)
       b.add(:psi, "\u03c8", :identifier)
@@ -278,7 +288,18 @@ module AsciiMath
       b
     end
 
-    DEFAULT_DISPLAY_SYMBOL_TABLE = ::AsciiMath::MarkupBuilder.add_default_display_symbols(AsciiMath::SymbolTableBuilder.new).build
+    private
+    DEFAULT_SYMBOL_TABLE = ::AsciiMath::MarkupBuilder.add_default_display_symbols(AsciiMath::SymbolTableBuilder.new, fix_phi: false).build
+    DEFAULT_SYMBOL_TABLE_FIX_PHI = ::AsciiMath::MarkupBuilder.add_default_display_symbols(AsciiMath::SymbolTableBuilder.new, fix_phi: true).build
+
+    public
+    def self.default_display_symbol_table(fix_phi: true)
+      if fix_phi
+        DEFAULT_SYMBOL_TABLE_FIX_PHI
+      else
+        DEFAULT_SYMBOL_TABLE
+      end
+    end
 
     def initialize(symbol_table)
       @symbol_table = symbol_table
@@ -312,7 +333,7 @@ module AsciiMath
         when ::AsciiMath::AST::Number
           append_number(node.value)
         when ::AsciiMath::AST::Identifier
-          append_identifier(node.value)
+          append_identifier_or_operator(node.value)
         when ::AsciiMath::AST::Symbol
           if (symbol = resolve_symbol(node))
             case symbol[:type]
@@ -322,12 +343,12 @@ module AsciiMath
                 append_identifier(symbol[:value])
             end
           else
-            append_identifier(node[:value])
+            append_identifier_or_operator(node[:value])
           end
         when ::AsciiMath::AST::Paren
           append_paren(resolve_paren(node.lparen), node.expression, resolve_paren(node.rparen), opts)
         when ::AsciiMath::AST::SubSup
-          if (resolve_symbol(node.base_expression) || {})[:underover]
+          if is_underover(node.base_expression)
             append_underover(node.base_expression, node.sub_expression, node.sup_expression)
           else
             append_subsup(node.base_expression, node.sub_expression, node.sup_expression)
@@ -366,6 +387,8 @@ module AsciiMath
                 append_root(node.operand2, node.operand1)
               when :color
                 append_color(node.operand1.to_hex_rgb, node.operand2)
+              when :frac
+                append_fraction(node.operand1, node.operand2)
             end
           end
         when ::AsciiMath::AST::InfixOp
@@ -388,6 +411,14 @@ module AsciiMath
       raise NotImplementedError.new __method__.to_s
     end
 
+    def append_identifier_or_operator(value)
+      if value.empty? || value =~ /[[:alnum:]].*/
+        append_identifier(value)
+      else
+        append_operator(value)
+      end
+    end
+
     def append_identifier(identifier)
       raise NotImplementedError.new __method__.to_s
     end
@@ -475,5 +506,21 @@ module AsciiMath
           nil
       end
     end
+
+    def is_accent(node)
+      resolved = resolve_symbol(node)
+      !resolved.nil? && resolved[:type] == :accent
+    end
+
+    def is_underover(node)
+      case node
+      when AsciiMath::AST::UnaryOp
+        symbol = node.operator
+      else
+        symbol = node
+      end
+
+      (resolve_symbol(symbol) || {})[:underover]
+    end
   end
 end

data/lib/asciimath/mathml.rb

@@ -5,7 +5,7 @@ module AsciiMath
   class MathMLBuilder < ::AsciiMath::MarkupBuilder
 
     def initialize(opts = {})
-      super(opts[:symbol_table] || DEFAULT_DISPLAY_SYMBOL_TABLE)
+      super(opts[:symbol_table] || ::AsciiMath::MarkupBuilder.default_display_symbol_table(fix_phi: opts.fetch(:fix_phi, true)))
       @prefix = opts[:prefix] || ''
       @mathml = ''
       if opts[:msword]
@@ -15,6 +15,7 @@ module AsciiMath
         @row_mode = :avoid
         @fence_mode = :row
       end
+      @escape_non_ascii = opts.fetch(:escape_non_ascii, true)
     end
 
     def to_s
@@ -149,21 +150,37 @@ module AsciiMath
     end
 
     def append_underover(base, sub, sup)
+      attrs = {}
+
+      sub_row_mode = @row_mode
+      if is_accent(sub)
+        attrs[:accentunder] = true
+        sub_row_mode = :avoid
+      end
+
+      sup_row_mode = @row_mode
+      if is_accent(sup)
+        attrs[:accent] = true
+        sup_row_mode = :avoid
+      end
+
+
+
       if sub && sup
-        munderover do
+        munderover(attrs) do
           append(base, :row => @row_mode)
-          append(sub, :row => @row_mode)
-          append(sup, :row => @row_mode)
+          append(sub, :row => sub_row_mode)
+          append(sup, :row => sup_row_mode)
         end
       elsif sub
-        munder do
+        munder(attrs) do
           append(base, :row => @row_mode)
-          append(sub, :row => @row_mode)
+          append(sub, :row => sub_row_mode)
         end
       elsif sup
-        mover do
+        mover(attrs) do
           append(base, :row => @row_mode)
-          append(sup, :row => @row_mode)
+          append(sup, :row => sup_row_mode)
         end
       else
         append(base)
@@ -223,7 +240,7 @@ module AsciiMath
           @mathml << "&lt;"
         elsif cp == 62
           @mathml << "&gt;"
-        elsif cp > 127
+        elsif cp > 127 && @escape_non_ascii
           @mathml << "&#x#{cp.to_s(16).upcase};"
         else
           @mathml << cp

data/lib/asciimath/parser.rb

@@ -253,7 +253,9 @@ module AsciiMath
       b.add('!=', 'ne', :ne, :symbol)
       b.add(':=', :assign, :symbol)
       b.add('<', 'lt', :lt, :symbol)
+      b.add('mlt', :mlt, :symbol)
       b.add('>', 'gt', :gt, :symbol)
+      b.add('mgt', :mgt, :symbol)
       b.add('<=', 'le', :le, :symbol)
       b.add('>=', 'ge', :ge, :symbol)
       b.add('-<', '-lt', 'prec', :prec, :symbol)
@@ -267,6 +269,7 @@ module AsciiMath
       b.add('sube', 'subseteq', :subseteq, :symbol)
       b.add('supe', 'supseteq', :supseteq, :symbol)
       b.add('-=', 'equiv', :equiv, :symbol)
+      b.add('~', 'sim', :sim, :symbol)
       b.add('~=', 'cong', :cong, :symbol)
       b.add('~~', 'approx', :approx, :symbol)
       b.add('prop', 'propto', :propto, :symbol)
@@ -312,6 +315,7 @@ module AsciiMath
       b.add('del', 'partial', :partial, :symbol)
       b.add('grad', 'nabla', :nabla, :symbol)
       b.add('+-', 'pm', :pm, :symbol)
+      b.add('-+', 'mp', :mp, :symbol)
       b.add('O/', 'emptyset', :emptyset, :symbol)
       b.add('oo', 'infty', :infty, :symbol)
       b.add('aleph', :aleph, :symbol)
@@ -441,6 +445,7 @@ module AsciiMath
       b.add('bsf', :bold_sans_serif, :unary)
       b.add('sfi', :sans_serif_italic, :unary)
       b.add('sfbi', :sans_serif_bold_italic, :unary)
+      b.add('rm', :roman, :unary)
 
       # Greek letters
       b.add('alpha', :alpha, :symbol)
@@ -506,7 +511,7 @@ module AsciiMath
     def parse(input)
       Expression.new(
           input,
-          parse_expression(Tokenizer.new(input, @symbol_table), 0)
+          parse_expression(Tokenizer.new(input, @symbol_table), nil)
       )
     end
 
@@ -514,36 +519,36 @@ module AsciiMath
 
     include AsciiMath::AST
 
-    def parse_expression(tok, depth)
-      e = []
+    def parse_expression(tok, close_paren_type)
+      e = nil
 
-      while (s1 = parse_intermediate_expression(tok, depth))
+      while (i1 = parse_intermediate_expression(tok, close_paren_type))
         t1 = tok.next_token
 
         if t1[:type] == :infix && t1[:value] == :frac
-          s2 = parse_intermediate_expression(tok, depth)
-          if s2
-            e << infix(unwrap_paren(s1), symbol(:frac, t1[:text]), unwrap_paren(s2))
+          i2 = parse_intermediate_expression(tok, close_paren_type)
+          if i2
+            e = concat_expressions(e, infix(unwrap_paren(i1), token_to_symbol(t1), unwrap_paren(i2)))
           else
-            e << s1
+            e = concat_expressions(e, i1)
           end
         elsif t1[:type] == :eof
-          e << s1
+          e = concat_expressions(e, i1)
           break
         else
-          e << s1
+          e = concat_expressions(e, i1)
           tok.push_back(t1)
-          if (t1[:type] == :lrparen || t1[:type] == :rparen) && depth > 0
+          if t1[:type] == close_paren_type
             break
           end
         end
       end
 
-      expression(*e)
+      e
     end
 
-    def parse_intermediate_expression(tok, depth)
-      s = parse_simple_expression(tok, depth)
+    def parse_intermediate_expression(tok, close_paren_type)
+      s = parse_simple_expression(tok, close_paren_type)
       sub = nil
       sup = nil
 
@@ -552,17 +557,17 @@ module AsciiMath
         when :infix
           case t1[:value]
             when :sub
-              sub = parse_simple_expression(tok, depth)
+              sub = parse_simple_expression(tok, close_paren_type)
               if sub
                 t2 = tok.next_token
                 if t2[:type] == :infix && t2[:value] == :sup
-                  sup = parse_simple_expression(tok, depth)
+                  sup = parse_simple_expression(tok, close_paren_type)
                 else
                   tok.push_back(t2)
                 end
               end
             when :sup
-              sup = parse_simple_expression(tok, depth)
+              sup = parse_simple_expression(tok, close_paren_type)
             else
               tok.push_back(t1)
           end
@@ -581,43 +586,55 @@ module AsciiMath
       end
     end
 
-    def parse_simple_expression(tok, depth)
+    def parse_simple_expression(tok, close_paren_type)
       t1 = tok.next_token
 
       case t1[:type]
         when :lparen, :lrparen
+          if t1[:type] == :lparen
+            close_with = :rparen
+          else
+            close_with = :lrparen
+          end
+
           t2 = tok.next_token
-          case t2[:type]
-            when :rparen, :lrparen
-              paren(token_to_symbol(t1), nil, token_to_symbol(t2))
-            else
-              tok.push_back(t2)
+          if t2[:type] == close_with
+            paren(token_to_symbol(t1), nil, token_to_symbol(t2))
+          else
+            tok.push_back(t2)
 
-              e = parse_expression(tok, depth + 1)
+            e = parse_expression(tok, close_with)
 
-              t2 = tok.next_token
-              case t2[:type]
-                when :rparen, :lrparen
-                  convert_to_matrix(paren(token_to_symbol(t1), e, token_to_symbol(t2)))
-                else
-                  tok.push_back(t2)
-                  paren(token_to_symbol(t1), e, nil)
+            t2 = tok.next_token
+            if t2[:type] == close_with
+              convert_to_matrix(paren(token_to_symbol(t1), e, token_to_symbol(t2)))
+            else
+              tok.push_back(t2)
+              if t1[:type] == :lrparen
+                concat_expressions(token_to_symbol(t1), e)
+              else
+                paren(token_to_symbol(t1), e, nil)
               end
+            end
           end
         when :rparen
-          if depth > 0
+          if close_paren_type.nil?
+            token_to_symbol(t1)
+          else
             tok.push_back(t1)
             nil
-          else
-            token_to_symbol(t1)
           end
         when :unary
-          s = unwrap_paren(parse_simple_expression(tok, depth))
+          parse_simple_expression = parse_simple_expression(tok, close_paren_type)
+          s = unwrap_paren(parse_simple_expression)
+          s = identifier('') if s.nil?
           s = convert_node(s, t1[:convert_operand])
           unary(token_to_symbol(t1), s)
         when :binary
-          s1 = unwrap_paren(parse_simple_expression(tok, depth))
-          s2 = unwrap_paren(parse_simple_expression(tok, depth))
+          s1 = unwrap_paren(parse_simple_expression(tok, close_paren_type))
+          s1 = identifier('') if s1.nil?
+          s2 = unwrap_paren(parse_simple_expression(tok, close_paren_type))
+          s2 = identifier('') if s2.nil?
 
           s1 = convert_node(s1, t1[:convert_operand1])
           s2 = convert_node(s2, t1[:convert_operand2])
@@ -636,12 +653,37 @@ module AsciiMath
       end
     end
 
+    def concat_expressions(e1, e2)
+      case e1
+        when Sequence
+          case e2
+            when Sequence
+              expression(*(e1.to_a), *(e2.to_a))
+            when nil
+              e1
+            else
+              expression(*(e1.to_a), e2)
+          end
+        when nil
+          e2
+        else
+          case e2
+            when Sequence
+              expression(e1, *(e2.to_a))
+            when nil
+              e1
+            else
+              expression(e1, e2)
+          end
+      end
+    end
+
     def token_to_symbol(t1)
-      symbol(t1[:value], t1[:text])
+      symbol(t1[:value], t1[:text], t1[:type])
     end
 
     def unwrap_paren(node)
-      if node.is_a?(::AsciiMath::AST::Paren)
+      if node.is_a?(::AsciiMath::AST::Paren) && (node.lparen.nil? || node.lparen.type == :lparen) && (node.rparen.nil? || node.rparen.type == :rparen)
         group(node.lparen, node.expression, node.rparen)
       else
         node
@@ -649,14 +691,23 @@ module AsciiMath
     end
 
     def convert_to_matrix(node)
-      return node unless node.is_a?(::AsciiMath::AST::Paren) && node.expression.is_a?(::AsciiMath::AST::Sequence)
+      return node unless node.is_a?(::AsciiMath::AST::Paren)
+
+      case node.expression
+      when ::AsciiMath::AST::Sequence
+        rows, separators = node.expression.partition.with_index { |obj, i| i.even? }
+      when ::AsciiMath::AST::Paren
+        rows = [node.expression]
+        separators = []
+      else
+        return node
+      end
 
-      rows, separators = node.expression.partition.with_index { |obj, i| i.even? }
-      return node unless rows.length > 1 &&
+      return node unless rows.length >= 1 &&
           rows.length > separators.length &&
           separators.all? { |item| is_matrix_separator(item) } &&
-          (rows.all? { |item| item.is_a?(::AsciiMath::AST::Paren) && item.lparen == symbol(:lparen, '(') && item.rparen == symbol(:rparen, ')') } ||
-              rows.all? { |item| item.is_a?(::AsciiMath::AST::Paren) && item.lparen == symbol(:lbracket, '[') && item.rparen == symbol(:rbracket, ']') })
+          (rows.all? { |item| item.is_a?(::AsciiMath::AST::Paren) && item.lparen == symbol(:lparen, '(', :lparen) && item.rparen == symbol(:rparen, ')', :rparen) } ||
+              rows.all? { |item| item.is_a?(::AsciiMath::AST::Paren) && item.lparen == symbol(:lbracket, '[', :lparen) && item.rparen == symbol(:rbracket, ']', :rparen) })
 
       rows = rows.map do |row|
         chunks = []
@@ -704,7 +755,6 @@ module AsciiMath
     def convert_to_color(color_expression)
       s = ""
       append_color_text(s, color_expression)
-      s
 
       case s
         when /#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})/i

data/lib/asciimath/version.rb

@@ -1,3 +1,3 @@
 module AsciiMath
-  VERSION = "2.0.1"
+  VERSION = "2.0.4"
 end

data/spec/ast.rb

@@ -90,7 +90,7 @@ module AsciiMath
     def symbol(text)
       symbol = ::AsciiMath::Parser::DEFAULT_PARSER_SYMBOL_TABLE[text]
       if symbol
-        ACTUAL_AST.symbol(symbol[:value], text)
+        ACTUAL_AST.symbol(symbol[:value], text, symbol[:type])
       else
         nil
       end

data/spec/customisation_spec.rb

@@ -14,7 +14,7 @@ describe 'AsciiMath::Parser', :variant => :ast do
     my_tokens_table.add('mysymbol', :mysymbol, :symbol)
 
     parsed = AsciiMath::parse("a + mysymbol + b", my_tokens_table.build)
-    expect(parsed.ast).to eq(seq(identifier('a'), symbol('+'), ::AsciiMath::AST::Symbol.new(:mysymbol, 'mysymbol'), symbol('+'), identifier('b')))
+    expect(parsed.ast).to eq(seq(identifier('a'), symbol('+'), ::AsciiMath::AST::Symbol.new(:mysymbol, 'mysymbol', :symbol), symbol('+'), identifier('b')))
   end
 
   it "should support replacing standard symbols" do
@@ -23,6 +23,6 @@ describe 'AsciiMath::Parser', :variant => :ast do
     my_tokens_table.add('+', :foo, :symbol)
 
     parsed = AsciiMath::parse("a + b", my_tokens_table.build)
-    expect(parsed.ast).to eq(seq(identifier('a'), ::AsciiMath::AST::Symbol.new(:foo, '+'), identifier('b')))
+    expect(parsed.ast).to eq(seq(identifier('a'), ::AsciiMath::AST::Symbol.new(:foo, '+', :symbol), identifier('b')))
   end
 end

data/spec/parser_spec.rb

@@ -7,11 +7,11 @@ require 'nokogiri'
 
 module Xml
   def self.mathml2_xsd
-    @schema ||= File.open(File.expand_path('../schema/mathml2/mathml2.xsd', __FILE__)) { |io| Nokogiri::XML::Schema(io) }
+    @mathml2_schema ||= File.open(File.expand_path('../schema/mathml2/mathml2.xsd', __FILE__)) { |io| Nokogiri::XML::Schema(io) }
   end
 
   def self.mathml3_xsd
-    @schema ||= File.open(File.expand_path('../schema/mathml3/mathml3.xsd', __FILE__)) { |io| Nokogiri::XML::Schema(io) }
+    @mathml3_schema ||= File.open(File.expand_path('../schema/mathml3/mathml3.xsd', __FILE__)) { |io| Nokogiri::XML::Schema(io) }
   end
 
   def self.parse(content)
@@ -31,12 +31,14 @@ def should_generate(expected_output)
             expect(parsed.ast).to eq(expected)
           when :mathml
             expect(parsed.to_mathml).to eq(expected)
-            xml_dom = Xml.parse(parsed.to_mathml(:xmlns => 'http://www.w3.org/1998/Math/MathML'))
-            Xml.mathml2_xsd.validate(xml_dom).each do |error|
-              fail(error.message)
-            end
-            Xml.mathml3_xsd.validate(xml_dom).each do |error|
-              fail(error.message)
+            if defined?(RUBY_ENGINE) && RUBY_ENGINE != 'jruby'
+              xml_dom = Xml.parse(parsed.to_mathml(:xmlns => 'http://www.w3.org/1998/Math/MathML'))
+              Xml.mathml2_xsd.validate(xml_dom).each do |error|
+                fail(error.message)
+              end
+              Xml.mathml3_xsd.validate(xml_dom).each do |error|
+                fail(error.message)
+              end
             end
           when :mathml_word
             expect(::AsciiMath::MathMLBuilder.new(:msword => true).append_expression(parsed.ast).to_s).to eq(expected)
@@ -74,8 +76,8 @@ RSpec.shared_examples 'AsciiMath Examples' do
           'j',
           sub(symbol('vartheta'), '0')
       ),
-      :mathml => '<math><munder><mover><mi>A</mi><mo>^</mo></mover><mo>_</mo></munder><mo>=</mo><mover><mi>A</mi><mo>^</mo></mover><mi>exp</mi><mi>j</mi><msub><mi>&#x3D1;</mi><mn>0</mn></msub></math>',
-      :mathml_word => '<math><munder><mrow><mover><mrow><mi>A</mi></mrow><mrow><mo>^</mo></mrow></mover></mrow><mrow><mo>_</mo></mrow></munder><mo>=</mo><mover><mrow><mi>A</mi></mrow><mrow><mo>^</mo></mrow></mover><mi>exp</mi><mi>j</mi><msub><mrow><mi>&#x3D1;</mi></mrow><mrow><mn>0</mn></mrow></msub></math>',
+      :mathml => '<math><munder><mover accent="true"><mi>A</mi><mo>^</mo></mover><mo>_</mo></munder><mo>=</mo><mover accent="true"><mi>A</mi><mo>^</mo></mover><mi>exp</mi><mi>j</mi><msub><mi>&#x3D1;</mi><mn>0</mn></msub></math>',
+      :mathml_word => '<math><munder><mrow><mover accent="true"><mrow><mi>A</mi></mrow><mo>^</mo></mover></mrow><mrow><mo>_</mo></mrow></munder><mo>=</mo><mover accent="true"><mrow><mi>A</mi></mrow><mo>^</mo></mover><mi>exp</mi><mi>j</mi><msub><mrow><mi>&#x3D1;</mi></mrow><mrow><mn>0</mn></mrow></msub></math>',
       :latex => '\\underset{\\text{–}}{\\hat{A}} = \\hat{A} \\exp j \\vartheta_0'
   ))
 
@@ -272,7 +274,7 @@ RSpec.shared_examples 'AsciiMath Examples' do
           unary(symbol('ul'), group('A')),
           unary(symbol('vec'), group('v')),
       ),
-      :mathml => '<math><mover><mrow><mi>a</mi><mi>b</mi></mrow><mo>^</mo></mover><mover><mrow><mi>x</mi><mi>y</mi></mrow><mo>&#xAF;</mo></mover><munder><mi>A</mi><mo>_</mo></munder><mover><mi>v</mi><mo>&#x2192;</mo></mover></math>',
+      :mathml => '<math><mover accent="true"><mrow><mi>a</mi><mi>b</mi></mrow><mo>^</mo></mover><mover accent="true"><mrow><mi>x</mi><mi>y</mi></mrow><mo>&#xAF;</mo></mover><munder accentunder="true"><mi>A</mi><mo>_</mo></munder><mover accent="true"><mi>v</mi><mo>&#x2192;</mo></mover></math>',
       :html => '<span class="math-inline"><span class="math-blank">&#x200D;</span><span class="math-underover"><span class="math-smaller"><span class="math-operator">^</span></span><span class="math-row"><span class="math-identifier">a</span><span class="math-identifier">b</span></span><span class="math-smaller"><span class="math-blank">&#x200D;</span></span></span><span class="math-blank">&#x200D;</span><span class="math-underover"><span class="math-smaller"><span class="math-operator">&#xAF;</span></span><span class="math-row"><span class="math-identifier">x</span><span class="math-identifier">y</span></span><span class="math-smaller"><span class="math-blank">&#x200D;</span></span></span><span class="math-blank">&#x200D;</span><span class="math-underover"><span class="math-smaller"><span class="math-blank">&#x200D;</span></span><span class="math-identifier">A</span><span class="math-smaller"><span class="math-operator">_</span></span></span><span class="math-blank">&#x200D;</span><span class="math-underover"><span class="math-smaller"><span class="math-operator">&#x2192;</span></span><span class="math-identifier">v</span><span class="math-smaller"><span class="math-blank">&#x200D;</span></span></span></span>',
       :latex => '\\hat{a b} \\overline{x y} \\underline{A} \\vec{v}',
   ))
@@ -326,6 +328,13 @@ RSpec.shared_examples 'AsciiMath Examples' do
       :latex => '\\left ( \\begin{matrix} 1 \\\\ 42 \\end{matrix} \\right )',
   ))
 
+  example('((1,42))', &should_generate(
+    :ast => matrix([%w[1 42]]),
+    :mathml => '<math><mrow><mo>(</mo><mtable><mtr><mtd><mn>1</mn></mtd><mtd><mn>42</mn></mtd></mtr></mtable><mo>)</mo></mrow></math>',
+    :html => '<span class="math-inline"><span class="math-row"><span class="math-brace" style="font-size: 100%;">(</span><span class="math-matrix" style="grid-template-columns:repeat(2,1fr);grid-template-rows:repeat(1,1fr);"><span class="math-row"><span class="math-number">1</span></span><span class="math-row"><span class="math-number">42</span></span></span><span class="math-brace" style="font-size: 100%;">)</span></span></span>',
+    :latex => '\\left ( \\begin{matrix} 1 & 42 \\end{matrix} \\right )',
+    ))
+
   example('((1,2,3),(4,5,6),(7,8,9))', &should_generate(
       :ast => matrix([%w[1 2 3], %w[4 5 6], %w[7 8 9]]),
       :mathml => '<math><mrow><mo>(</mo><mtable><mtr><mtd><mn>1</mn></mtd><mtd><mn>2</mn></mtd><mtd><mn>3</mn></mtd></mtr><mtr><mtd><mn>4</mn></mtd><mtd><mn>5</mn></mtd><mtd><mn>6</mn></mtd></mtr><mtr><mtd><mn>7</mn></mtd><mtd><mn>8</mn></mtd><mtd><mn>9</mn></mtd></mtr></mtable><mo>)</mo></mrow></math>',
@@ -335,7 +344,7 @@ RSpec.shared_examples 'AsciiMath Examples' do
 
   example('|(a,b),(c,d)|=ad-bc', &should_generate(
       :ast => seq(
-          matrix(symbol('|'), [%w(a b), %w(c d)], symbol('|'),),
+          matrix(symbol('|'), [%w(a b), %w(c d)], symbol('|')),
           symbol('='),
           'a', 'd',
           symbol('-'),
@@ -418,7 +427,7 @@ RSpec.shared_examples 'AsciiMath Examples' do
           unary(symbol('ubrace'), grseq('1', symbol('+'), '2')),
           unary(symbol('obrace'), group(symbol('('), seq('3', symbol('+'), '4'), nil))
       ),
-      :mathml => '<math><munder><mrow><mn>1</mn><mo>+</mo><mn>2</mn></mrow><mo>&#x23DF;</mo></munder><mover><mrow><mn>3</mn><mo>+</mo><mn>4</mn></mrow><mo>&#x23DE;</mo></mover></math>',
+      :mathml => '<math><munder accentunder="true"><mrow><mn>1</mn><mo>+</mo><mn>2</mn></mrow><mo>&#x23DF;</mo></munder><mover accent="true"><mrow><mn>3</mn><mo>+</mo><mn>4</mn></mrow><mo>&#x23DE;</mo></mover></math>',
       :latex => '\\underbrace{1 + 2} \\overbrace{3 + 4}',
   ))
 
@@ -519,7 +528,7 @@ RSpec.shared_examples 'AsciiMath Examples' do
 
   example('overarc a_b^c', &should_generate(
       :ast => subsup(unary(symbol('overarc'), 'a'), 'b', 'c'),
-      :mathml => '<math><msubsup><mover><mi>a</mi><mo>&#x23DC;</mo></mover><mi>b</mi><mi>c</mi></msubsup></math>',
+      :mathml => '<math><msubsup><mover accent="true"><mi>a</mi><mo>&#x23DC;</mo></mover><mi>b</mi><mi>c</mi></msubsup></math>',
       :latex => '{\\overset{\\frown}{a}}_b^c'
   ))
 
@@ -568,10 +577,79 @@ RSpec.shared_examples 'AsciiMath Examples' do
           seq('x', symbol('\ '), ':', symbol('\ '), 'x', symbol('in'), 'A', symbol('^^'), 'x', symbol('in'), 'B'),
           symbol('}')
       ),
-      :mathml => '<math><mrow><mo>{</mo><mrow><mi>x</mi><mo>&#xA0;</mo><mi>:</mi><mo>&#xA0;</mo><mi>x</mi><mo>&#x2208;</mo><mi>A</mi><mo>&#x2227;</mo><mi>x</mi><mo>&#x2208;</mo><mi>B</mi></mrow><mo>}</mo></mrow></math>',
+      :mathml => '<math><mrow><mo>{</mo><mrow><mi>x</mi><mo>&#xA0;</mo><mo>:</mo><mo>&#xA0;</mo><mi>x</mi><mo>&#x2208;</mo><mi>A</mi><mo>&#x2227;</mo><mi>x</mi><mo>&#x2208;</mo><mi>B</mi></mrow><mo>}</mo></mrow></math>',
       :latex => '\\left \\{ x \\; : \\; x \\in A \\wedge x \\in B \\right \\}',
   ))
 
+  example('ii', &should_generate(
+      :ast => unary(symbol('ii'), identifier('')),
+      :mathml => '<math><mstyle mathvariant="italic"><mi></mi></mstyle></math>'
+  ))
+
+  example('rm(ms)', &should_generate(
+      :ast => unary(symbol('rm'), grseq(identifier('m'), identifier('s'))),
+      :mathml => '<math><mstyle mathvariant="normal"><mrow><mi>m</mi><mi>s</mi></mrow></mstyle></math>'
+  ))
+
+  example('hat', &should_generate(
+      :ast => unary(symbol('hat'), identifier('')),
+      :mathml => '<math><mover accent="true"><mi></mi><mo>^</mo></mover></math>'
+  ))
+
+  example('40% * 3!', &should_generate(
+    :ast => seq('40', '%', symbol('*'), '3', '!'),
+    :mathml => '<math><mn>40</mn><mo>%</mo><mo>&#x22C5;</mo><mn>3</mn><mo>!</mo></math>',
+    :html => '<span class="math-inline"><span class="math-number">40</span><span class="math-operator">%</span><span class="math-operator">&#x22C5;</span><span class="math-number">3</span><span class="math-operator">!</span></span>',
+    :latex => '40 \% \cdot 3 !'
+  ))
+
+  example('R(alpha_(K+1)|x)', &should_generate(
+    :ast => seq('R', paren(symbol('('), seq(sub('alpha', grseq('K', symbol('+'), '1')), symbol('|'), 'x'), symbol(')'))),
+    :mathml => '<math><mi>R</mi><mrow><mo>(</mo><mrow><msub><mi>&#x3B1;</mi><mrow><mi>K</mi><mo>+</mo><mn>1</mn></mrow></msub><mo>|</mo><mi>x</mi></mrow><mo>)</mo></mrow></math>',
+    :latex => 'R \\left ( \\alpha_{K + 1} | x \\right )'
+  ))
+
+  example('|(a),(b)|', &should_generate(
+    :ast => matrix(symbol('|'), [%w(a), %w(b)], symbol('|')),
+  ))
+
+  example('|a+b|', &should_generate(
+    :ast => paren(symbol('|'), seq('a', '+', 'b'), symbol('|')),
+  ))
+
+  example('|a+b|/c', &should_generate(
+    :ast => infix(paren(symbol('|'), seq('a', '+', 'b'), symbol('|')), '/', 'c'),
+  ))
+
+  example('[[a,b,|,c],[d,e,|,f]]', &should_generate(
+    :ast => matrix(symbol('['), [['a', 'b', symbol('|'), 'c'], ['d', 'e', symbol('|'), 'f']], symbol(']')),
+  ))
+
+  example('~a mlt b mgt -+c', &should_generate(
+    :ast => seq(symbol('~'), 'a', symbol('mlt'), 'b', symbol('mgt'), symbol('-+'), 'c'),
+    :latex => '\\sim a \\ll b \\gg \\mp c',
+    :mathml => '<math><mo>&#x223C;</mo><mi>a</mi><mo>&#x226A;</mo><mi>b</mi><mo>&#x226B;</mo><mo>&#x2213;</mo><mi>c</mi></math>'
+    ))
+
+  example('a+b+...+c', &should_generate(
+    :ast => seq('a', symbol('+'), 'b', symbol('+'), symbol('...'), symbol('+'), 'c'),
+    :latex => 'a + b + \ldots + c',
+    :mathml => '<math><mi>a</mi><mo>+</mo><mi>b</mi><mo>+</mo><mo>&#x2026;</mo><mo>+</mo><mi>c</mi></math>'
+    ))
+
+  example('frac{a}{b}', &should_generate(
+    :ast => binary('frac', group(symbol('{'), 'a', symbol('}')), group(symbol('{'), 'b', symbol('}'))),
+    :latex => '\frac{a}{b}',
+    :mathml => '<math><mfrac><mi>a</mi><mi>b</mi></mfrac></math>'
+  ))
+
+  example('ubrace(((1, 0),(0, 1)))_("Adjustment to texture space")', &should_generate(
+    :ast => subsup(unary(symbol('ubrace'), group(matrix([%w[1 0], %w[0 1]]))), group("Adjustment to texture space"), []),
+    :latex => '\underbrace{\left ( \begin{matrix} 1 & 0 \\\\ 0 & 1 \end{matrix} \right )}_{\text{Adjustment to texture space}}',
+    :mathml => '<math><munder><munder accentunder="true"><mrow><mo>(</mo><mtable><mtr><mtd><mn>1</mn></mtd><mtd><mn>0</mn></mtd></mtr><mtr><mtd><mn>0</mn></mtd><mtd><mn>1</mn></mtd></mtr></mtable><mo>)</mo></mrow><mo>&#x23DF;</mo></munder><mtext>Adjustment to texture space</mtext></munder></math>'
+  ))
+
+
   version = RUBY_VERSION.split('.').map { |s| s.to_i }
 
   if version[0] > 1 || version[1] > 8

metadata

@@ -1,72 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: asciimath
 version: !ruby/object:Gem::Version
-  version: 2.0.1
+  version: 2.0.4
 platform: ruby
 authors:
 - Pepijn Van Eeckhoudt
 - Gark Garcia
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-06-29 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">"
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">"
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 13.0.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 13.0.0
-- !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 3.9.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 3.9.0
-- !ruby/object:Gem::Dependency
-  name: nokogiri
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.10.9
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.10.9
+date: 2022-04-21 00:00:00.000000000 Z
+dependencies: []
 description: A pure Ruby AsciiMath parsing and conversion library.
 email:
 - pepijn@vaneeckhoudt.net
@@ -76,8 +20,8 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/ci.yml"
 - ".gitignore"
-- ".travis.yml"
 - AST.adoc
 - CHANGELOG.adoc
 - Gemfile
@@ -141,7 +85,7 @@ homepage: ''
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -156,9 +100,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
-signing_key: 
+rubygems_version: 3.2.22
+signing_key:
 specification_version: 4
 summary: AsciiMath parser and converter
 test_files:

data/.travis.yml

@@ -1,16 +0,0 @@
-language: ruby
-cache:
-  apt: true
-  directories:
-    - vendor/bundle
-    - $HOME/.cache/pip
-rvm:
-  - 2.3
-  - 2.4
-  - 2.5
-  - jruby
-  - truffleruby
-before_install:
-  - type bundle || gem install bundler --version '~> 1.0'
-install:
-  - bundle install --path vendor/bundle --jobs=3 --retry=3