html2doc 0.8.6 → 0.8.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a1e07932ce2329645bb69ae3c9c5f401d229d3080be417428e5aa36b900d9f6c
-  data.tar.gz: 9e916f0a465fa1e11d693fcfc04197f7fcfae0b423da255bb3c4cdc3a02a61f7
+  metadata.gz: 8b4a4257cfea9d3621715b98d906f8eb0ffdc7ce49f38b732dc2aada2e7bf122
+  data.tar.gz: a767085867c7dc1eb105e90eeb221ba4c89383dad79a61615df7e03615f890fb
 SHA512:
-  metadata.gz: 3bad513cc61d42db8d5bd24b7e0b0eaf66c631d40d39128817549a84e8c8d3f9fbd917b5a1fff949d57604981833f64579e9e630ead7366feb1694510bb42591
-  data.tar.gz: 6733ac123a379ca70712acdc39f32048ee6220f4b58e894af93df87c84defb382ffec978fc6cc084f6fb1b040da3fe5dffdc111c237d4d6afce4cf397a42144e
+  metadata.gz: 0d47018c5d6c3d9432f860485994462cfc6634d487de4a72375df7974b9af51d0409c5ac0bdc1ffcac585c51fc329b5d39cb4c1e6810821ba6489dfbd4b4e557
+  data.tar.gz: 5067f79bb2dca4836021d960d807a9ec81a97b5ec3545588fe60120e98d2d46f26665f7a5ac0c6ffd5bed50e7f858017f1fd6677edd8e10958240afae11c23bc

data/.rubocop.yml

@@ -3,13 +3,8 @@
 # All project-specific additions and overrides should be specified in this file.
 
 inherit_from:
-  # Thoughtbot's style guide from: https://github.com/thoughtbot/guides
-  - ".rubocop.tb.yml"
-  # Overrides from Ribose
-  - ".rubocop.ribose.yml"
+  - https://raw.githubusercontent.com/riboseinc/oss-guides/master/ci/rubocop.yml
 AllCops:
-  DisplayCopNames: false
-  StyleGuideCopsOnly: false
-  TargetRubyVersion: 2.4
+  TargetRubyVersion: 2.3
 Rails:
   Enabled: true

data/Gemfile

@@ -3,8 +3,7 @@ source "https://rubygems.org"
 group :development, :test do
   gem "rspec"
 end
-
-
+ 
 git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
 
 # Specify your gem's dependencies in html2doc.gemspec

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    html2doc (0.8.6)
+    html2doc (0.8.7)
       asciimath
       htmlentities (~> 4.3.4)
       image_size
@@ -14,7 +14,7 @@ PATH
 GEM
   remote: https://rubygems.org/
   specs:
-    asciimath (1.0.6)
+    asciimath (1.0.7)
     ast (2.4.0)
     byebug (9.1.0)
     coderay (1.1.2)
@@ -22,9 +22,9 @@ GEM
     docile (1.3.1)
     equivalent-xml (0.6.0)
       nokogiri (>= 1.4.3)
-    ffi (1.9.25)
+    ffi (1.10.0)
     formatador (0.2.5)
-    guard (2.14.2)
+    guard (2.15.0)
       formatador (>= 0.2.4)
       listen (>= 2.7, < 4.0)
       lumberjack (>= 1.0.12, < 2.0)
@@ -40,21 +40,20 @@ GEM
       rspec (>= 2.99.0, < 4.0)
     htmlentities (4.3.4)
     image_size (2.0.0)
-    jaro_winkler (1.5.1)
     json (2.1.0)
     listen (3.1.5)
       rb-fsevent (~> 0.9, >= 0.9.4)
       rb-inotify (~> 0.9, >= 0.9.7)
       ruby_dep (~> 1.2)
     lumberjack (1.0.13)
-    method_source (0.9.0)
+    method_source (0.9.2)
     mime-types (3.2.2)
       mime-types-data (~> 3.2015)
     mime-types-data (3.2018.0812)
-    mini_portile2 (2.3.0)
+    mini_portile2 (2.4.0)
     nenv (0.3.0)
-    nokogiri (1.8.5)
-      mini_portile2 (~> 2.3.0)
+    nokogiri (1.10.0)
+      mini_portile2 (~> 2.4.0)
     notiffany (0.1.1)
       nenv (~> 0.1)
       shellany (~> 0.0)
@@ -62,14 +61,14 @@ GEM
     parser (2.5.3.0)
       ast (~> 2.4.0)
     powerpack (0.1.2)
-    pry (0.11.3)
+    pry (0.12.2)
       coderay (~> 1.1.0)
       method_source (~> 0.9.0)
     rainbow (3.0.0)
-    rake (12.3.1)
+    rake (12.3.2)
     rb-fsevent (0.10.3)
-    rb-inotify (0.9.10)
-      ffi (>= 0.5.0, < 2)
+    rb-inotify (0.10.0)
+      ffi (~> 1.0)
     rspec (3.8.0)
       rspec-core (~> 3.8.0)
       rspec-expectations (~> 3.8.0)
@@ -85,14 +84,13 @@ GEM
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.8.0)
     rspec-support (3.8.0)
-    rubocop (0.60.0)
-      jaro_winkler (~> 1.5.1)
+    rubocop (0.54.0)
       parallel (~> 1.10)
-      parser (>= 2.5, != 2.5.1.1)
+      parser (>= 2.5)
       powerpack (~> 0.1)
       rainbow (>= 2.2.2, < 4.0)
       ruby-progressbar (~> 1.7)
-      unicode-display_width (~> 1.4.0)
+      unicode-display_width (~> 1.0, >= 1.0.1)
     ruby-progressbar (1.10.0)
     ruby-xslt (0.9.10)
     ruby_dep (1.5.0)
@@ -102,17 +100,17 @@ GEM
       json (>= 1.8, < 3)
       simplecov-html (~> 0.10.0)
     simplecov-html (0.10.2)
-    thor (0.20.0)
+    thor (0.20.3)
     thread_safe (0.3.6)
     timecop (0.9.1)
-    unicode-display_width (1.4.0)
+    unicode-display_width (1.4.1)
     uuidtools (2.1.5)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
-  bundler (~> 1.15)
+  bundler (~> 2.0.1)
   byebug (~> 9.1)
   equivalent-xml (~> 0.6)
   guard (~> 2.14)
@@ -121,9 +119,9 @@ DEPENDENCIES
   rake (~> 12.0)
   rspec
   rspec-match_fuzzy (~> 0.1.3)
-  rubocop (~> 0.50)
+  rubocop (= 0.54.0)
   simplecov (~> 0.15)
   timecop (~> 0.9)
 
 BUNDLED WITH
-   1.17.1
+   2.0.1

data/html2doc.gemspec

@@ -34,14 +34,14 @@ Gem::Specification.new do |spec|
   spec.add_dependency "ruby-xslt"
   spec.add_dependency "asciimath"
 
-  spec.add_development_dependency "bundler", "~> 1.15"
+  spec.add_development_dependency "bundler", "~> 2.0.1"
   spec.add_development_dependency "byebug", "~> 9.1"
   spec.add_development_dependency "equivalent-xml", "~> 0.6"
   spec.add_development_dependency "guard", "~> 2.14"
   spec.add_development_dependency "guard-rspec", "~> 4.7"
   spec.add_development_dependency "rake", "~> 12.0"
   spec.add_development_dependency "rspec", "~> 3.6"
-  spec.add_development_dependency "rubocop", "~> 0.50"
+  spec.add_development_dependency "rubocop", "= 0.54.0"
   spec.add_development_dependency "simplecov", "~> 0.15"
   spec.add_development_dependency "timecop", "~> 0.9"
   spec.add_development_dependency "rspec-match_fuzzy", "~> 0.1.3"

data/lib/asciimath/cli.rb

@@ -0,0 +1,18 @@
+require_relative 'parser'
+require_relative 'mathml'
+require_relative 'html'
+
+module AsciiMath
+  module CLI
+    def self.run(args)
+      asciimath = args.last
+      output = ''
+      if args.length == 1 || args.first == "mathml"
+        output = AsciiMath.parse(asciimath).to_mathml
+      elsif args.first == "html"
+        output = AsciiMath.parse(asciimath).to_html
+      end
+      puts output
+    end
+  end
+end

data/lib/asciimath/html.rb

@@ -0,0 +1,222 @@
+module AsciiMath
+  class HTMLBuilder
+    def initialize(prefix)
+      @prefix = prefix
+      @html = ''
+    end
+
+    def to_s
+      @html
+    end
+
+    def append_expression(expression, inline, attrs = {})
+      if inline
+        inline('', attrs) do
+          append(expression, :single_child => true)
+        end
+      else
+        block('', attrs) do
+          append(expression, :single_child => true)
+        end
+      end
+    end
+
+    private
+
+    ZWJ = "\u8205"
+
+    def append(expression, opts = {})
+      case expression
+        when Array
+          row do
+            expression.each { |e| append(e) }
+          end
+        when Hash
+          case expression[:type]
+            when :operator
+              operator(expression[:c])
+            when :identifier
+              identifier(expression[:c])
+            when :number
+              number(expression[:c])
+            when :text
+              text(expression[:c])
+            when :paren
+              paren = !opts[:strip_paren]
+              if paren
+                if opts[:single_child]
+                  brace(expression[:lparen]) if expression[:lparen]
+                  append(expression[:e], :single_child => true)
+                  brace(expression[:rparen]) if expression[:rparen]
+                else
+                  row do
+                    brace(expression[:lparen]) if expression[:lparen]
+                    append(expression[:e], :single_child => true)
+                    brace(expression[:rparen]) if expression[:rparen]
+                  end
+                end
+              else
+                append(expression[:e])
+              end
+            when :font
+              #TODO - currently ignored
+            when :unary
+              operator = expression[:operator]
+              tag(operator) do
+                append(expression[:s], :single_child => true, :strip_paren => true)
+              end
+            when :binary
+              operator = expression[:operator]
+              if operator == :frac
+                append_fraction(expression[:s1],expression[:s2])
+              elsif operator == :sub
+                append_subsup(expression[:s1],expression[:s2],nil)
+              elsif operator == :sup
+                append_subsup(expression[:s1],nil,expression[:s2])
+              elsif operator == :under
+                append_underover(expression[:s1],expression[:s2],nil)
+              elsif operator == :over
+                append_underover(expression[:s1],nil,expression[:s2])
+              else
+                tag(operator) do
+                  append(expression[:s1], :strip_paren => true)
+                  append(expression[:s2], :strip_paren => true)
+                end
+              end
+            when :ternary
+              operator = expression[:operator]
+              if operator == :subsup
+                append_subsup(expression[:s1],expression[:s2],expression[:s3])
+              elsif operator == :underover
+                # TODO: Handle over/under braces in some way? SVG maybe?
+                append_underover(expression[:s1],expression[:s2],expression[:s3])
+              end
+            when :matrix
+              row do
+                # Figures out a font size for the braces, based on the height of the matrix.
+                # NOTE: This does not currently consider the size of each element within the matrix.
+                brace_height = "font-size: " + expression[:rows].length.to_s + "00%;"
+                
+                if expression[:lparen]
+                  brace(expression[:lparen], {:style => brace_height})
+                else
+                  blank(ZWJ)
+                end
+                matrix_width  = "grid-template-columns:repeat(" + expression[:rows][0].length.to_s + ",1fr);"
+                matrix_height = "grid-template-rows:repeat(" + expression[:rows].length.to_s + ",1fr);"
+                
+                matrix({:style => (matrix_width + matrix_height)}) do
+                  expression[:rows].each do |row|
+                    row.each do |col|
+                      row do
+                        append(col)
+                      end
+                    end
+                  end
+                end
+                if expression[:rparen]
+                  brace(expression[:rparen], {:style => brace_height})
+                else
+                  blank(ZWJ)
+                end
+              end
+          end
+      end
+    end
+    
+    def append_subsup(base, sub, sup)
+      append(base)
+      subsup do
+        if sup
+          smaller do
+            append(sup, :strip_paren => true)
+          end
+        else
+          smaller(ZWJ)
+        end
+        if sub
+          smaller do
+            append(sub, :strip_paren => true)
+          end
+        else
+          smaller(ZWJ)
+        end
+      end
+    end
+    
+    def append_underover(base, under, over)
+      blank(ZWJ)
+      underover do
+        smaller do
+          if over
+            append(over, :strip_paren => true)
+          else
+            blank(ZWJ)
+          end
+        end
+        append(base)
+        smaller do
+          if under
+            append(under, :strip_paren => true)
+          else
+            blank(ZWJ)
+          end
+        end
+      end
+    end
+        
+    def append_fraction(numerator, denominator)
+      blank(ZWJ)
+      fraction do
+        fraction_row do
+          fraction_cell do
+            smaller do
+              row do
+                append(numerator, :strip_paren => true)
+              end
+            end
+          end
+        end
+        fraction_row do
+          fraction_cell do
+            smaller do
+              row do
+                append(denominator, :strip_paren => true)
+              end
+            end
+          end
+        end
+      end
+    end
+
+    def method_missing(meth, *args, &block)
+      tag(meth, *args, &block)
+    end
+    
+    def tag(tag, *args)
+      attrs = args.last.is_a?(Hash) ? args.pop : {}
+      text = args.last.is_a?(String) ? args.pop : ''
+
+      @html << '<span class="math-' << @prefix << tag.to_s << '"'
+
+      attrs.each_pair do |key, value|
+        @html << ' ' << key.to_s << '="' << value.to_s << '"'
+      end
+
+      if block_given? || text
+        @html << '>'
+        @html << text.encode(Encoding::US_ASCII, :xml => :text) if text
+        yield if block_given?
+        @html << '</span>'
+      else
+        @html << '/>'
+      end
+    end
+  end
+
+  class Expression
+    def to_html(prefix = "", inline = true, attrs = {})
+      HTMLBuilder.new(prefix).append_expression(@parsed_expression, inline, attrs).to_s
+    end
+  end
+end

data/lib/asciimath/mathml.rb

@@ -0,0 +1,131 @@
+module AsciiMath
+  class MathMLBuilder
+    def initialize(prefix)
+      @prefix = prefix
+      @mathml = ''
+    end
+
+    def to_s
+      @mathml
+    end
+
+    def append_expression(expression, attrs = {})
+      math('', attrs) do
+        append(expression, :single_child => true)
+      end
+    end
+
+    private
+
+    def append(expression, opts = {})
+      case expression
+        when Array
+          if expression.length <= 1 || opts[:single_child]
+            expression.each { |e| append(e) }
+          else
+            mrow do
+              expression.each { |e| append(e) }
+            end
+          end
+        when Hash
+          case expression[:type]
+            when :operator
+              mo(expression[:c])
+            when :identifier
+              mi(expression[:c])
+            when :number
+              mn(expression[:c])
+            when :text
+              mtext(expression[:c])
+            when :paren
+              paren = !opts[:strip_paren]
+              if paren
+                if opts[:single_child]
+                  mo(expression[:lparen]) if expression[:lparen]
+                  append(expression[:e], :single_child => true)
+                  mo(expression[:rparen]) if expression[:rparen]
+                else
+                  mrow do
+                    mo(expression[:lparen]) if expression[:lparen]
+                    append(expression[:e], :single_child => true)
+                    mo(expression[:rparen]) if expression[:rparen]
+                  end
+                end
+              else
+                append(expression[:e])
+              end
+            when :font
+              style = expression[:operator]
+              tag("mstyle", :mathvariant => style.to_s.gsub('_', '-')) do
+                append(expression[:s], :single_child => true, :strip_paren => true)
+              end
+            when :unary
+              operator = expression[:operator]
+              tag("m#{operator}") do
+                append(expression[:s], :single_child => true, :strip_paren => true)
+              end
+            when :binary
+              operator = expression[:operator]
+              tag("m#{operator}") do
+                append(expression[:s1], :strip_paren => (operator != :sub && operator != :sup))
+                append(expression[:s2], :strip_paren => true)
+              end
+            when :ternary
+              operator = expression[:operator]
+              tag("m#{operator}") do
+                append(expression[:s1])
+                append(expression[:s2], :strip_paren => true)
+                append(expression[:s3], :strip_paren => true)
+              end
+            when :matrix
+              mrow do
+                mo(expression[:lparen]) if expression[:lparen]
+                mtable do
+                  expression[:rows].each do |row|
+                    mtr do
+                      row.each do |col|
+                        mtd do
+                          append(col)
+                        end
+                      end
+                    end
+                  end
+                end
+                mo(expression[:rparen]) if expression[:rparen]
+              end
+          end
+      end
+    end
+
+    def method_missing(meth, *args, &block)
+      tag(meth, *args, &block)
+    end
+
+    def tag(tag, *args)
+      attrs = args.last.is_a?(Hash) ? args.pop : {}
+      text = args.last.is_a?(String) ? args.pop : ''
+
+      @mathml << '<' << @prefix << tag.to_s
+
+      attrs.each_pair do |key, value|
+        @mathml << ' ' << key.to_s << '="' << value.to_s << '"'
+      end
+
+
+      if block_given? || text
+        @mathml << '>'
+        @mathml << text.encode(Encoding::US_ASCII, :xml => :text) if text
+        yield self if block_given?
+        @mathml << '</' << @prefix << tag.to_s << '>'
+      else
+        @mathml << '/>'
+      end
+    end
+  end
+
+  class Expression
+    def to_mathml(prefix = "", attrs = {})
+      MathMLBuilder.new(prefix).append_expression(@parsed_expression, attrs).to_s
+    end
+  end
+end

data/lib/asciimath/parser.rb

@@ -0,0 +1,591 @@
+require 'strscan'
+
+# Parser for ASCIIMath expressions.
+#
+# The syntax for ASCIIMath in EBNF style notation is
+#
+# expr = ( simp ( fraction | sub | super ) )+
+# simp = constant | paren_expr | unary_expr | binary_expr | text
+# fraction = '/' simp
+# super = '^' simp
+# sub =  '_' simp super?
+# paren_expr = lparen expr rparen
+# lparen = '(' | '[' | '{' | '(:' | '{:'
+# rparen = ')' | ']' | '}' | ':)' | ':}'
+# unary_expr = unary_op simp
+# unary_op = 'sqrt' | 'text'
+# binary_expr = binary_op simp simp
+# binary_op = 'frac' | 'root' | 'stackrel'
+# text = '"' [^"]* '"'
+# constant = number | symbol | identifier
+# number = '-'? [0-9]+ ( '.' [0-9]+ )?
+# symbol = /* any string in the symbol table */
+# identifier = [A-z]
+#
+# ASCIIMath is parsed left to right without any form of operator precedence.
+# When parsing the 'constant' the parser will try to find the longest matching string in the symbol
+# table starting at the current position of the parser. If no matching string can be found the
+# character at the current position of the parser is interpreted as an identifier instead.
+module AsciiMath
+  # Internal: Splits an ASCIIMath expression into a sequence of tokens.
+  # Each token is represented as a Hash containing the keys :value and :type.
+  # The :value key is used to store the text associated with each token.
+  # The :type key indicates the semantics of the token. The value for :type will be one
+  # of the following symbols:
+  #
+  # - :identifier a symbolic name or a bit of text without any further semantics
+  # - :text a bit of arbitrary text
+  # - :number a number
+  # - :operator a mathematical operator symbol
+  # - :unary a unary operator (e.g., sqrt, text, ...)
+  # - :font a unary font command (e.g., bb, cc, ...)
+  # - :infix an infix operator (e.g, /, _, ^, ...)
+  # - :binary a binary operator (e.g., frac, root, ...)
+  # - :accent an accent character
+  # - :eof indicates no more tokens are available
+  #
+  # Each token type may also have an :underover modifier. When present and set to true
+  # sub- and superscript expressions associated with the token will be rendered as
+  # under- and overscriptabove and below rather than as sub- or superscript.
+  #
+  # :accent tokens additionally have a :postion value which is set to either :over or :under.
+  # This determines if the accent should be rendered over or under the expression to which
+  # it applies.
+  #
+  class Tokenizer
+    WHITESPACE = /^\s+/
+    NUMBER = /-?[0-9]+(?:\.[0-9]+)?/
+    QUOTED_TEXT = /"[^"]*"/
+    TEX_TEXT = /text\([^)]*\)/
+
+    # Public: Initializes an ASCIIMath tokenizer.
+    #
+    # string - The ASCIIMath expression to tokenize
+    # symbols - The symbol table to use while tokenizing
+    def initialize(string, symbols)
+      @string = StringScanner.new(string)
+      @symbols = symbols
+      lookahead = @symbols.keys.map { |k| k.length }.max
+      @symbol_regexp = /([^\s0-9]{1,#{lookahead}})/
+      @push_back = nil
+    end
+
+    # Public: Read the next token from the ASCIIMath expression and move the tokenizer
+    # ahead by one token.
+    #
+    # Returns the next token as a Hash
+    def next_token
+      if @push_back
+        t = @push_back
+        @push_back = nil
+        return t
+      end
+
+      @string.scan(WHITESPACE)
+
+      return {:value => nil, :type => :eof} if @string.eos?
+
+      case @string.peek(1)
+      when '"'
+        read_quoted_text
+      when 't'
+        case @string.peek(5)
+        when 'text('
+          read_tex_text
+        else
+          read_symbol
+        end
+      when '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9'
+        read_number || read_symbol
+      else
+        read_symbol
+      end
+    end
+
+    # Public: Pushes the given token back to the tokenizer. A subsequent call to next_token
+    # will return the given token rather than generating a new one. At most one
+    # token can be pushed back.
+    #
+    # token - The token to push back
+    def push_back(token)
+      @push_back = token unless token[:type] == :eof
+    end
+
+    private
+
+    # Private: Reads a text token from the input string
+    #
+    # Returns the text token or nil if a text token could not be matched at
+    # the current position
+    def read_quoted_text
+      read_value(QUOTED_TEXT) do |text|
+        {:value => text[1..-2], :type => :text}
+      end
+    end
+
+    # Private: Reads a text token from the input string
+    #
+    # Returns the text token or nil if a text token could not be matched at
+    # the current position
+    def read_tex_text
+      read_value(TEX_TEXT) do |text|
+        {:value => text[5..-2], :type => :text}
+      end
+    end
+
+    # Private: Reads a number token from the input string
+    #
+    # Returns the number token or nil if a number token could not be matched at
+    # the current position
+    def read_number
+      read_value(NUMBER) do |number|
+        {:value => number, :type => :number}
+      end
+    end
+
+    if String.method_defined?(:bytesize)
+      def bytesize(s)
+        s.bytesize
+      end
+    else
+      def bytesize(s)
+        s.length
+      end
+    end
+
+
+    # Private: Reads a symbol token from the input string. This method first creates
+    # a String from the input String starting from the current position with a length
+    # that matches that of the longest key in the symbol table. It then looks up that
+    # substring in the symbol table. If the substring is present in the symbol table, the
+    # associated value is returned and the position is moved ahead by the length of the
+    # substring. Otherwise this method chops one character off the end of the substring
+    # and repeats the symbol lookup. This continues until a single character is left.
+    # If that character can still not be found in the symbol table, then an identifier
+    # token is returned whose value is the remaining single character string.
+    #
+    # Returns the token that was read or nil if a token could not be matched at
+    # the current position
+    def read_symbol
+      position = @string.pos
+      read_value(@symbol_regexp) do |s|
+        until s.length == 1 || @symbols.include?(s)
+          s.chop!
+        end
+        @string.pos = position + bytesize(s)
+        @symbols[s] || {:value => s, :type => :identifier}
+      end
+    end
+
+    # Private: Reads a String from the input String that matches the given RegExp
+    #
+    # regexp - a RegExp that will be used to match the token
+    # block  - if a block is provided the matched token will be passed to the block
+    #
+    # Returns the matched String or the value returned by the block if one was given
+    def read_value(regexp)
+      s = @string.scan(regexp)
+      if s
+        yield s
+      else
+        s
+      end
+    end
+
+    if String.respond_to?(:byte_size)
+      def byte_size(s)
+        s.byte_size
+      end
+    end
+  end
+
+  class Parser
+    SYMBOLS = {
+        # Operation symbols
+        '+' => {:value => '+', :type => :operator},
+        '-' => {:value => "\u2212", :type => :operator},
+        '*' => {:value => "\u22C5", :type => :operator},
+        '**' => {:value => "\u002A", :type => :operator},
+        '***' => {:value => "\u22C6", :type => :operator},
+        '//' => {:value => '/', :type => :operator},
+        '\\\\' => {:value => '\\', :type => :operator},
+        'xx' => {:value => "\u00D7", :type => :operator},
+        '-:' => {:value => "\u00F7", :type => :operator},
+        '|><' => {:value => "\u22C9", :type => :operator},
+        '><|' => {:value => "\u22CA", :type => :operator},
+        '|><|' => {:value => "\u22C8", :type => :operator},
+        '@' => {:value => "\u26AC", :type => :operator},
+        'o+' => {:value => "\u2295", :type => :operator},
+        'ox' => {:value => "\u2297", :type => :operator},
+        'o.' => {:value => "\u2299", :type => :operator},
+        'sum' => {:value => "\u2211", :type => :operator, :underover => true},
+        'prod' => {:value => "\u220F", :type => :operator, :underover => true},
+        '^^' => {:value => "\u2227", :type => :operator},
+        '^^^' => {:value => "\u22C0", :type => :operator, :underover => true},
+        'vv' => {:value => "\u2228", :type => :operator},
+        'vvv' => {:value => "\u22C1", :type => :operator, :underover => true},
+        'nn' => {:value => "\u2229", :type => :operator},
+        'nnn' => {:value => "\u22C2", :type => :operator, :underover => true},
+        'uu' => {:value => "\u222A", :type => :operator},
+        'uuu' => {:value => "\u22C3", :type => :operator, :underover => true},
+
+        # Relation symbols
+        '=' => {:value => '=', :type => :operator},
+        '!=' => {:value => "\u2260", :type => :operator},
+        ':=' => {:value => ':=', :type => :operator},
+        '<' => {:value => "\u003C", :type => :operator},
+        'lt' => {:value => "\u003C", :type => :operator},
+        '>' => {:value => "\u003E", :type => :operator},
+        'gt' => {:value => "\u003E", :type => :operator},
+        '<=' => {:value => "\u2264", :type => :operator},
+        'le' => {:value => "\u2264", :type => :operator},
+        '>=' => {:value => "\u2265", :type => :operator},
+        'ge' => {:value => "\u2265", :type => :operator},
+        '-<' => {:value => "\u227A", :type => :operator},
+        '>-' => {:value => "\u227B", :type => :operator},
+        '-<=' => {:value => "\u2AAF", :type => :operator},
+        '>-=' => {:value => "\u2AB0", :type => :operator},
+        'in' => {:value => "\u2208", :type => :operator},
+        '!in' => {:value => "\u2209", :type => :operator},
+        'sub' => {:value => "\u2282", :type => :operator},
+        'sup' => {:value => "\u2283", :type => :operator},
+        'sube' => {:value => "\u2286", :type => :operator},
+        'supe' => {:value => "\u2287", :type => :operator},
+        '-=' => {:value => "\u2261", :type => :operator},
+        '~=' => {:value => "\u2245", :type => :operator},
+        '~~' => {:value => "\u2248", :type => :operator},
+        'prop' => {:value => "\u221D", :type => :operator},
+
+        # Logical symbols
+        'and' => {:value => 'and', :type => :text},
+        'or' => {:value => 'or', :type => :text},
+        'not' => {:value => "\u00AC", :type => :operator},
+        '=>' => {:value => "\u21D2", :type => :operator},
+        'if' => {:value => 'if', :type => :operator},
+        '<=>' => {:value => "\u21D4", :type => :operator},
+        'AA' => {:value => "\u2200", :type => :operator},
+        'EE' => {:value => "\u2203", :type => :operator},
+        '_|_' => {:value => "\u22A5", :type => :operator},
+        'TT' => {:value => "\u22A4", :type => :operator},
+        '|--' => {:value => "\u22A2", :type => :operator},
+        '|==' => {:value => "\u22A8", :type => :operator},
+
+        # Grouping brackets
+        '(' => {:value => '(', :type => :lparen},
+        ')' => {:value => ')', :type => :rparen},
+        '[' => {:value => '[', :type => :lparen},
+        ']' => {:value => ']', :type => :rparen},
+        '{' => {:value => '{', :type => :lparen},
+        '}' => {:value => '}', :type => :rparen},
+        '(:' => {:value => "\u2329", :type => :lparen},
+        ':)' => {:value => "\u232A", :type => :rparen},
+        '<<' => {:value => "\u2329", :type => :lparen},
+        '>>' => {:value => "\u232A", :type => :rparen},
+        '|' => {:value => '|', :type => :lrparen},
+        '||' => {:value => '||', :type => :lrparen},
+        '{:' => {:value => nil, :type => :lparen},
+        ':}' => {:value => nil, :type => :rparen},
+
+        # Miscellaneous symbols
+        'int' => {:value => "\u222B", :type => :operator},
+        'dx' => {:value => 'dx', :type => :identifier},
+        'dy' => {:value => 'dy', :type => :identifier},
+        'dz' => {:value => 'dz', :type => :identifier},
+        'dt' => {:value => 'dt', :type => :identifier},
+        'oint' => {:value => "\u222E", :type => :operator},
+        'del' => {:value => "\u2202", :type => :operator},
+        'grad' => {:value => "\u2207", :type => :operator},
+        '+-' => {:value => "\u00B1", :type => :operator},
+        'O/' => {:value => "\u2205", :type => :operator},
+        'oo' => {:value => "\u221E", :type => :operator},
+        'aleph' => {:value => "\u2135", :type => :operator},
+        '...' => {:value => '...', :type => :operator},
+        ':.' => {:value => "\u2234", :type => :operator},
+        '/_' => {:value => "\u2220", :type => :operator},
+        '\\ ' => {:value => "\u00A0", :type => :operator},
+        'quad' => {:value => '\u00A0\u00A0', :type => :operator},
+        'qquad' => {:value => '\u00A0\u00A0\u00A0\u00A0', :type => :operator},
+        'cdots' => {:value => "\u22EF", :type => :operator},
+        'vdots' => {:value => "\u22EE", :type => :operator},
+        'ddots' => {:value => "\u22F1", :type => :operator},
+        'diamond' => {:value => "\u22C4", :type => :operator},
+        'square' => {:value => "\u25A1", :type => :operator},
+        '|__' => {:value => "\u230A", :type => :operator},
+        '__|' => {:value => "\u230B", :type => :operator},
+        '|~' => {:value => "\u2308", :type => :operator},
+        '~|' => {:value => "\u2309", :type => :operator},
+        'CC' => {:value => "\u2102", :type => :operator},
+        'NN' => {:value => "\u2115", :type => :operator},
+        'QQ' => {:value => "\u211A", :type => :operator},
+        'RR' => {:value => "\u211D", :type => :operator},
+        'ZZ' => {:value => "\u2124", :type => :operator},
+
+        'lim' => {:value => 'lim', :type => :operator, :underover => true},
+        'Lim' => {:value => 'Lim', :type => :operator, :underover => true},
+
+        # Standard functions
+        'sin' => {:value => 'sin', :type => :identifier},
+        'cos' => {:value => 'cos', :type => :identifier},
+        'tan' => {:value => 'tan', :type => :identifier},
+        'sec' => {:value => 'sec', :type => :identifier},
+        'csc' => {:value => 'csc', :type => :identifier},
+        'cot' => {:value => 'cot', :type => :identifier},
+        'arcsin' => {:value => 'arcsin', :type => :identifier},
+        'arccos' => {:value => 'arccos', :type => :identifier},
+        'arctan' => {:value => 'arctan', :type => :identifier},
+        'sinh' => {:value => 'sinh', :type => :identifier},
+        'cosh' => {:value => 'cosh', :type => :identifier},
+        'tanh' => {:value => 'tanh', :type => :identifier},
+        'sech' => {:value => 'sech', :type => :identifier},
+        'csch' => {:value => 'csch', :type => :identifier},
+        'coth' => {:value => 'coth', :type => :identifier},
+        'exp' => {:value => 'exp', :type => :identifier},
+        'log' => {:value => 'log', :type => :identifier},
+        'ln' => {:value => 'ln', :type => :identifier},
+        'det' => {:value => 'det', :type => :identifier},
+        'dim' => {:value => 'dim', :type => :identifier},
+        'mod' => {:value => 'mod', :type => :identifier},
+        'gcd' => {:value => 'gcd', :type => :identifier},
+        'lcm' => {:value => 'lcm', :type => :identifier},
+        'lub' => {:value => 'lub', :type => :identifier},
+        'glb' => {:value => 'glb', :type => :identifier},
+        'min' => {:value => 'min', :type => :identifier, :underover => true},
+        'max' => {:value => 'max', :type => :identifier, :underover => true},
+        'f' => {:value => 'f', :type => :identifier},
+        'g' => {:value => 'g', :type => :identifier},
+
+        # Accents
+        'hat' => {:value => "\u005E", :type => :accent, :position => :over},
+        'bar' => {:value => "\u00AF", :type => :accent, :position => :over},
+        'ul' => {:value => '_', :type => :accent, :position => :under},
+        'vec' => {:value => "\u2192", :type => :accent, :position => :over},
+        'dot' => {:value => '.', :type => :accent, :position => :over},
+        'ddot' => {:value => '..', :type => :accent, :position => :over},
+        'obrace' => {:value => "\u23DE", :type => :accent, :position => :over},
+        'ubrace' => {:value => "\u23DF", :type => :accent, :position => :under},
+
+        # Arrows
+        'uarr' => {:value => "\u2191", :type => :operator},
+        'darr' => {:value => "\u2193", :type => :operator},
+        'rarr' => {:value => "\u2192", :type => :operator},
+        '->' => {:value => "\u2192", :type => :operator},
+        '>->' => {:value => "\u21A3", :type => :operator},
+        '->>' => {:value => "\u21A0", :type => :operator},
+        '>->>' => {:value => "\u2916", :type => :operator},
+        '|->' => {:value => "\u21A6", :type => :operator},
+        'larr' => {:value => "\u2190", :type => :operator},
+        'harr' => {:value => "\u2194", :type => :operator},
+        'rArr' => {:value => "\u21D2", :type => :operator},
+        'lArr' => {:value => "\u21D0", :type => :operator},
+        'hArr' => {:value => "\u21D4", :type => :operator},
+
+        # Other
+        'sqrt' => {:value => :sqrt, :type => :unary},
+        'text' => {:value => :text, :type => :unary},
+        'bb' => {:value => :bold, :type => :font},
+        'bbb' => {:value => :double_struck, :type => :font},
+        'ii' => {:value => :italic, :type => :font},
+        'bii' => {:value => :bold_italic, :type => :font},
+        'cc' => {:value => :script, :type => :font},
+        'bcc' => {:value => :bold_script, :type => :font},
+        'tt' => {:value => :monospace, :type => :font},
+        'fr' => {:value => :fraktur, :type => :font},
+        'bfr' => {:value => :bold_fraktur, :type => :font},
+        'sf' => {:value => :sans_serif, :type => :font},
+        'bsf' => {:value => :bold_sans_serif, :type => :font},
+        'sfi' => {:value => :sans_serif_italic, :type => :font},
+        'sfbi' => {:value => :sans_serif_bold_italic, :type => :font},
+        'frac' => {:value => :frac, :type => :binary},
+        'root' => {:value => :root, :type => :binary},
+        'stackrel' => {:value => :over, :type => :binary},
+        '/' => {:value => :frac, :type => :infix},
+        '_' => {:value => :sub, :type => :infix},
+        '^' => {:value => :sup, :type => :infix},
+
+        # Greek letters
+        'alpha' => {:value => "\u03b1", :type => :identifier},
+        'Alpha' => {:value => "\u0391", :type => :identifier},
+        'beta' => {:value => "\u03b2", :type => :identifier},
+        'Beta' => {:value => "\u0392", :type => :identifier},
+        'gamma' => {:value => "\u03b3", :type => :identifier},
+        'Gamma' => {:value => "\u0393", :type => :operator},
+        'delta' => {:value => "\u03b4", :type => :identifier},
+        'Delta' => {:value => "\u0394", :type => :operator},
+        'epsilon' => {:value => "\u03b5", :type => :identifier},
+        'Epsilon' => {:value => "\u0395", :type => :identifier},
+        'varepsilon' => {:value => "\u025b", :type => :identifier},
+        'zeta' => {:value => "\u03b6", :type => :identifier},
+        'Zeta' => {:value => "\u0396", :type => :identifier},
+        'eta' => {:value => "\u03b7", :type => :identifier},
+        'Eta' => {:value => "\u0397", :type => :identifier},
+        'theta' => {:value => "\u03b8", :type => :identifier},
+        'Theta' => {:value => "\u0398", :type => :operator},
+        'vartheta' => {:value => "\u03d1", :type => :identifier},
+        'iota' => {:value => "\u03b9", :type => :identifier},
+        'Iota' => {:value => "\u0399", :type => :identifier},
+        'kappa' => {:value => "\u03ba", :type => :identifier},
+        'Kappa' => {:value => "\u039a", :type => :identifier},
+        'lambda' => {:value => "\u03bb", :type => :identifier},
+        'Lambda' => {:value => "\u039b", :type => :operator},
+        'mu' => {:value => "\u03bc", :type => :identifier},
+        'Mu' => {:value => "\u039c", :type => :identifier},
+        'nu' => {:value => "\u03bd", :type => :identifier},
+        'Nu' => {:value => "\u039d", :type => :identifier},
+        'xi' => {:value => "\u03be", :type => :identifier},
+        'Xi' => {:value => "\u039e", :type => :operator},
+        'omicron' => {:value => "\u03bf", :type => :identifier},
+        'Omicron' => {:value => "\u039f", :type => :identifier},
+        'pi' => {:value => "\u03c0", :type => :identifier},
+        'Pi' => {:value => "\u03a0", :type => :operator},
+        'rho' => {:value => "\u03c1", :type => :identifier},
+        'Rho' => {:value => "\u03a1", :type => :identifier},
+        'sigma' => {:value => "\u03c3", :type => :identifier},
+        'Sigma' => {:value => "\u03a3", :type => :operator},
+        'tau' => {:value => "\u03c4", :type => :identifier},
+        'Tau' => {:value => "\u03a4", :type => :identifier},
+        'upsilon' => {:value => "\u03c5", :type => :identifier},
+        'Upsilon' => {:value => "\u03a5", :type => :identifier},
+        'phi' => {:value => "\u03c6", :type => :identifier},
+        'Phi' => {:value => "\u03a6", :type => :identifier},
+        'varphi' => {:value => "\u03d5", :type => :identifier},
+        'chi' => {:value => '\u03b3c7', :type => :identifier},
+        'Chi' => {:value => '\u0393a7', :type => :identifier},
+        'psi' => {:value => "\u03c8", :type => :identifier},
+        'Psi' => {:value => "\u03a8", :type => :identifier},
+        'omega' => {:value => "\u03c9", :type => :identifier},
+        'Omega' => {:value => "\u03a9", :type => :operator},
+    }
+
+    def parse(input)
+      Expression.new(
+          input,
+          parse_expression(Tokenizer.new(input, SYMBOLS), 0)
+      )
+    end
+
+    private
+    def parse_expression(tok, depth)
+      e = []
+
+      while (s1 = parse_simple_expression(tok, depth))
+        t1 = tok.next_token
+
+        if t1[:type] == :infix
+          s2 = parse_simple_expression(tok, depth)
+          t2 = tok.next_token
+          if t1[:value] == :sub && t2[:value] == :sup
+            s3 = parse_simple_expression(tok, depth)
+            operator = s1[:underover] ? :underover : :subsup
+            e << {:type => :ternary, :operator => operator, :s1 => s1, :s2 => s2, :s3 => s3}
+          else
+            operator = s1[:underover] ? (t1[:value] == :sub ? :under : :over) : t1[:value]
+            e << {:type => :binary, :operator => operator, :s1 => s1, :s2 => s2}
+            tok.push_back(t2)
+            if (t2[:type] == :lrparen || t2[:type] == :rparen) && depth > 0
+              break
+            end
+          end
+        elsif t1[:type] == :eof
+          e << s1
+          break
+        else
+          e << s1
+          tok.push_back(t1)
+          if (t1[:type] == :lrparen || t1[:type] == :rparen) && depth > 0
+            break
+          end
+        end
+      end
+
+      e
+    end
+
+    def parse_simple_expression(tok, depth)
+      t1 = tok.next_token
+
+      case t1[:type]
+        when :lparen, :lrparen
+          t2 = tok.next_token
+          case t2[:type]
+            when :rparen, :lrparen
+              {:type => :paren, :e => nil, :lparen => t1[:value], :rparen => t2[:value]}
+            else
+              tok.push_back(t2)
+
+              e = parse_expression(tok, depth + 1)
+
+              t2 = tok.next_token
+              case t2[:type]
+                when :rparen, :lrparen
+                  convert_to_matrix({:type => :paren, :e => e, :lparen => t1[:value], :rparen => t2[:value]})
+                else
+                  tok.push_back(t2)
+                  {:type => :paren, :e => e, :lparen => t1[:value]}
+              end
+          end
+        when :accent
+          s = parse_simple_expression(tok, depth)
+          {:type => :binary, :s1 => s, :s2 => {:type => :operator, :c => t1[:value]}, :operator => t1[:position]}
+        when :unary, :font
+          s = parse_simple_expression(tok, depth)
+          {:type => t1[:type], :s => s, :operator => t1[:value]}
+        when :binary
+          s1 = parse_simple_expression(tok, depth)
+          s2 = parse_simple_expression(tok, depth)
+          {:type => :binary, :s1 => s1, :s2 => s2, :operator => t1[:value]}
+        when :eof
+          nil
+        else
+          {:type => t1[:type], :c => t1[:value], :underover => t1[:underover]}
+      end
+    end
+
+    def convert_to_matrix(expression)
+      return expression unless matrix? expression
+
+      rows = expression[:e].select.with_index { |obj, i| i.even? }.map do |row|
+        row[:e].select.with_index { |obj, i| i.even? }
+      end
+
+      {:type => :matrix, :rows => rows, :lparen => expression[:lparen], :rparen => expression[:rparen]}
+    end
+
+    def matrix?(expression)
+      return false unless expression.is_a?(Hash) && expression[:type] == :paren
+
+      rows, separators = expression[:e].partition.with_index { |obj, i| i.even? }
+
+      rows.length > 1 &&
+          rows.length > separators.length &&
+          separators.all? { |item| item[:type] == :identifier && item[:c] == ',' } &&
+          (rows.all? { |item| item[:type] == :paren && item[:lparen] == '(' && item[:rparen] == ')' } ||
+              rows.all? { |item| item[:type] == :paren && item[:lparen] == '[' && item[:rparen] == ']' }) &&
+          rows.all? { |item| item[:e].length == rows[0][:e].length } &&
+          rows.all? { |item| matrix_cols?(item[:e]) }
+    end
+
+    def matrix_cols?(expression)
+      return false unless expression.is_a?(Array)
+
+      cols, separators = expression.partition.with_index { |obj, i| i.even? }
+
+      cols.all? { |item| item[:type] != :identifier || item[:c] != ',' } &&
+          separators.all? { |item| item[:type] == :identifier && item[:c] == ',' }
+    end
+  end
+
+  class Expression
+    def initialize(asciimath, parsed_expression)
+      @asciimath = asciimath
+      @parsed_expression = parsed_expression
+    end
+
+    def to_s
+      @asciimath
+    end
+  end
+
+  def self.parse(asciimath)
+    Parser.new.parse(asciimath)
+  end
+end

data/lib/asciimath/version.rb

@@ -0,0 +1,3 @@
+module AsciiMath
+  VERSION = "1.0.7.pre1"
+end

data/lib/html2doc.rb

@@ -4,3 +4,6 @@ require_relative "html2doc/mime"
 require_relative "html2doc/notes"
 require_relative "html2doc/math"
 require_relative "html2doc/lists"
+#require_relative "asciimath/parser"
+#require_relative "asciimath/mathml"
+#require_relative "asciimath/html"

data/lib/html2doc/base.rb

@@ -44,6 +44,7 @@ module Html2Doc
   end
 
   def self.cleanup(docxml, hash)
+    namespace(docxml.root)
     image_cleanup(docxml, hash[:dir1], File.dirname(hash[:filename]))
     mathml_to_ooml(docxml)
     lists(docxml, hash[:liststyles])
@@ -91,6 +92,12 @@ module Html2Doc
     r.gsub!(%r{<meta http-equiv="Content-Type"},
             "<meta http-equiv=Content-Type")
     r.gsub!(%r{></m:jc>}, "/>")
+    r.gsub!(%r{></v:stroke>}, "/>")
+    r.gsub!(%r{></v:f>}, "/>")
+    r.gsub!(%r{></v:path>}, "/>")
+    r.gsub!(%r{></o:lock>}, "/>")
+    r.gsub!(%r{></v:imagedata>}, "/>")
+    r.gsub!(%r{></w:wrap>}, "/>")
     r.gsub!(%r{&tab;|&amp;tab;}, '<span style="mso-tab-count:1">&#xA0; </span>')
     r
   end
@@ -142,7 +149,7 @@ module Html2Doc
     css = stylesheet(hash[:filename], hash[:header_file], hash[:stylesheet])
     add_stylesheet(head, title, css)
     define_head1(docxml, hash[:dir1])
-    namespace(docxml.root)
+    rootnamespace(docxml.root)
   end
 
   def self.add_stylesheet(head, title, css)
@@ -162,12 +169,16 @@ module Html2Doc
       v: "urn:schemas-microsoft-com:vml",
       m: "http://schemas.microsoft.com/office/2004/12/omml",
     }.each { |k, v| root.add_namespace_definition(k.to_s, v) }
+  end
+
+  def self.rootnamespace(root)
     root.add_namespace(nil, "http://www.w3.org/TR/REC-html40")
   end
 
   def self.bookmarks(docxml)
     docxml.xpath("//*[@id][not(@name)][not(@style = 'mso-element:footnote')]").each do |x|
       next if x["id"].empty?
+      next if %w(shapetype v:shapetype shape v:shape).include? x.name
       if x.children.empty?
         x.add_child("<a name='#{x["id"]}'></a>")
       else

data/lib/html2doc/mime.rb

@@ -83,7 +83,9 @@ module Html2Doc
 
   # only processes locally stored images
   def self.image_cleanup(docxml, dir, localdir)
-    docxml.xpath(IMAGE_PATH).each do |i|
+    #docxml.xpath(IMAGE_PATH).each do |i|
+    docxml.traverse do |i|
+      next unless i.element? && %w(img v:imagedata).include?(i.name)
       warnsvg(i["src"])
       next if /^http/.match i["src"]
       local_filename = File.join(localdir, i["src"])

data/lib/html2doc/version.rb

@@ -1,3 +1,3 @@
 module Html2Doc
-  VERSION = "0.8.6".freeze
+  VERSION = "0.8.7".freeze
 end

data/spec/html2doc_spec.rb

@@ -383,7 +383,7 @@ RSpec.describe Html2Doc do
   end
 
   it "processes AsciiMath" do
-    Html2Doc.process(html_input("<div>{{sum_(i=1)^n i^3=((n(n+1))/2)^2)}}</div>"), filename: "test", asciimathdelims: ["{{", "}}"])
+    Html2Doc.process(html_input(%[<div>{{sum_(i=1)^n i^3=((n(n+1))/2)^2 text("integer"))}}</div>]), filename: "test", asciimathdelims: ["{{", "}}"])
     expect(guid_clean(File.read("test.doc", encoding: "utf-8"))).
       to match_fuzzy(<<~OUTPUT)
     #{WORD_HDR} #{DEFAULT_STYLESHEET} #{WORD_HDR_END}
@@ -401,6 +401,7 @@ RSpec.describe Html2Doc do
        </m:num><m:den><m:r><m:t>2</m:t></m:r></m:den></m:f>
        <m:r><m:t>)</m:t></m:r>
        </m:e><m:sup><m:r><m:t>2</m:t></m:r></m:sup></m:sSup>
+       <m:r><m:rPr><m:nor></m:nor></m:rPr><m:t>"integer"</m:t></m:r>
        </m:oMath>
     </div>', '<div style="mso-element:footnote-list"/>')}
     #{WORD_FTR1}

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: html2doc
 version: !ruby/object:Gem::Version
-  version: 0.8.6
+  version: 0.8.7
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-10-31 00:00:00.000000000 Z
+date: 2019-01-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: htmlentities
@@ -128,14 +128,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.15'
+        version: 2.0.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.15'
+        version: 2.0.1
 - !ruby/object:Gem::Dependency
   name: byebug
   requirement: !ruby/object:Gem::Requirement
@@ -224,16 +224,16 @@ dependencies:
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - '='
       - !ruby/object:Gem::Version
-        version: '0.50'
+        version: 0.54.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - '='
       - !ruby/object:Gem::Version
-        version: '0.50'
+        version: 0.54.0
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
@@ -306,6 +306,11 @@ files:
 - bin/rspec
 - bin/setup
 - html2doc.gemspec
+- lib/asciimath/cli.rb
+- lib/asciimath/html.rb
+- lib/asciimath/mathml.rb
+- lib/asciimath/parser.rb
+- lib/asciimath/version.rb
 - lib/html2doc.rb
 - lib/html2doc/base.rb
 - lib/html2doc/lists.rb