umath 0.1.0

data/lib/umath/model.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Umath
+  # The typed UnicodeMath language model, declared with LutaML Model.
+  #
+  # Umath.parse returns a Model::Document. Its tree is built by
+  # lutaml-model from the declared attribute types (Document.new on the
+  # grammar's bound tree, see Parser); no code here walks the parse tree.
+  # The node classes in model/nodes.rb are generated from the normalized
+  # grammar's capture shapes (scripts/generate_model.rb), one class per
+  # capture; see docs/model-contract.adoc.
+  module Model
+    # The root: one parsed UnicodeMath formula.
+    #
+    # +expression+ is the formula's tree, nil for input without a formula
+    # (empty, or only "#" label separators). +label+ is the equation label,
+    # the text after the last "#" (nil when the input has none; the legacy
+    # facade rule). +decimal+ is the decimal marker the input was parsed
+    # with; numbers keep their digits and marker as written.
+    class Document < Lutaml::Model::Serializable
+      attribute :expression, "Umath::Model::Expression"
+      attribute :label, :string
+      attribute :decimal, :string
+    end
+  end
+end
+
+require_relative "model/nodes"

data/lib/umath/native_recursion_guard.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Umath
+  # Raised inside Parsanol's native error path when the native engine hit
+  # its recursion limit, before Parsanol's interpreter reparse runs (that
+  # reparse can take minutes or exhaust the Ruby stack on deep input).
+  class NativeRecursionLimit < Error; end
+  private_constant :NativeRecursionLimit
+
+  # Parsanol::Native.raise_native_parse_error translates a native failure.
+  # While Umath's own native call runs on this thread, this hook turns
+  # a recursion-limit failure into NativeRecursionLimit; every other failure,
+  # and every other caller of Parsanol, is unaffected. (The same guard as
+  # amath's.)
+  module NativeRecursionGuard
+    MESSAGE = /\A(?:Maximum recursion depth \(\d+\) exceeded|Recursion limit exceeded\b)/
+    KEY = :umath_native_recursion_guard
+
+    def self.watch
+      outer = Thread.current[KEY]
+      Thread.current[KEY] = true
+      yield
+    ensure
+      Thread.current[KEY] = outer
+    end
+
+    def self.installed?
+      Parsanol::Native.singleton_class.ancestors.include?(self)
+    end
+
+    def raise_native_parse_error(error, grammar, input)
+      if Thread.current[KEY] && error.message.match?(MESSAGE)
+        raise NativeRecursionLimit, error.message.lines.first.strip, cause: nil
+      end
+
+      super
+    end
+  end
+
+  if Parsanol::Native.singleton_class.method_defined?(:raise_native_parse_error)
+    Parsanol::Native.singleton_class.prepend(NativeRecursionGuard)
+  end
+end

data/lib/umath/parser.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Umath
+  # The public parser behind Umath.parse: preprocessing, grammar and
+  # bindings (RawParser), typed model construction by lutaml-model from the
+  # declared attribute types, then symbol resolution (Symbols.resolve).
+  module Parser
+    module_function
+
+    def parse(input, decimal: ".", engine: :ruby)
+      text = RawParser.normalize_input(input)
+      raw = begin
+        RawParser.parse(text, decimal: decimal, engine: engine)
+      rescue NestingTooDeep => e
+        raise NestingTooDeep.new(e.message, input: text, byte_offset: nil, char_offset: nil)
+      rescue ParseError => e
+        raise relocate(e, text)
+      end
+      # Input without a formula part (empty, or only "#" label separators):
+      # an empty Document. The legacy facade fails there with NoMethodError,
+      # so there is no legacy result to keep; amath returns an empty result
+      # for empty input too.
+      return Model::Document.new(label: raw.label, decimal: decimal) if raw.text.nil?
+
+      build(raw, decimal, text)
+    end
+
+    def build(raw, decimal, text)
+      document = Model::Document.new(expression: raw.model_data, label: raw.label, decimal: decimal)
+      Symbols.resolve(document)
+    rescue SystemStackError
+      raise NestingTooDeep.new("UnicodeMath input nests too deeply to build its model (Ruby stack exhausted)",
+                               input: text, byte_offset: nil, char_offset: nil)
+    end
+
+    # The grammar's error, with its offsets moved from the grammar input to
+    # the caller's text.
+    def relocate(error, text)
+      char = byte = nil
+      if error.char_offset
+        char, byte = SourceMap.build(text).caller_position(error.char_offset)
+      end
+      where = char ? " at character #{char} (byte #{byte})" : ""
+      detail = error.message.sub(/\AUnicodeMath input rejected( at character \d+ \(byte \d+\))?: /, "")
+      ParseError.new("UnicodeMath input rejected#{where}: #{detail}", input: text, byte_offset: byte, char_offset: char)
+    end
+
+    private_class_method :build, :relocate
+  end
+end

data/lib/umath/preprocessor.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Umath
+  # The legacy UnicodeMath preprocessing (Plurimath::UnicodeMath::Parser at
+  # the pinned oracle commit), step for step. The grammar runs on its
+  # result, never on the caller's text. See docs/parser-contract.adoc,
+  # "Preprocessing".
+  #
+  # Internal: the public parser owns this step.
+  module Preprocessor
+    # +text+ is the grammar input, or nil when the input has no formula part
+    # (an empty input, or one made only of label separators; the legacy code
+    # raises NoMethodError there). +label+ is the text after the last "#",
+    # set only when +labeled+.
+    Result = Struct.new(:text, :label, :labeled, keyword_init: true)
+
+    PEN_OPEN = "✎("
+    PROTECTED_HASH = "\"replacement\""
+    # HTMLEntities (xhtml1 flavour) with the :hexadecimal instruction: the
+    # basic characters first, then everything outside printable ASCII.
+    BASIC = /[<>'"&]/
+    EXTENDED = /[^\u{20}-\u{7E}]/
+    COMMENT_OPEN = "&#x2af7;"
+    COMMENT_CLOSE = "&#x2af8;"
+    U_ESCAPE = /\\u([\da-fA-F]{1,5})\w{0,5}/
+
+    module_function
+
+    # +input+ must be a valid UTF-8 String.
+    def call(input)
+      formula, label, labeled = split_label(input)
+      return Result.new(text: nil, label: label, labeled: labeled) if formula.nil?
+
+      text = encode(formula)
+      text = text.gsub("&#x26;", "&")
+      text = text.gsub("&#x22;", "\"")
+      text = remove_comment(text)
+      text = text.gsub("\\\\", "\\")
+      text = text.gsub(U_ESCAPE) { "&#x#{::Regexp.last_match(1)};" }
+      Result.new(text: text.strip, label: label, labeled: labeled)
+    end
+
+    # A "#" inside a ✎(...) group is protected; the text is then split on
+    # "#": the first part is the formula and, if there is more than one
+    # part, the last one is the label. Parts in between are dropped.
+    def split_label(input)
+      text = input.split("\n", -1).map { |line| protect_pen_group(line) }.join("\n")
+      parts = text.split("#")
+      return [nil, nil, false] if parts.empty?
+
+      formula = parts.first.gsub(PROTECTED_HASH, "#")
+      parts.size > 1 ? [formula, parts.last, true] : [formula, nil, false]
+    end
+
+    # Legacy: text.gsub(/✎\(.*(\#).*\)/) { |group| group.gsub("#", ...) }.
+    # Per line ("." stops at newlines) the only match runs from the first
+    # "✎(" to the last ")" when a "#" lies between them. Written out
+    # without the backtracking regexp, which is polynomial on long input.
+    def protect_pen_group(line)
+      start = line.index(PEN_OPEN) or return line
+      close = line.rindex(")")
+      return line unless close && close >= start + PEN_OPEN.length
+
+      hash = line.index("#", start + PEN_OPEN.length)
+      return line unless hash && hash < close
+
+      line[0...start] + line[start..close].gsub("#", PROTECTED_HASH) + line[(close + 1)..]
+    end
+
+    # Legacy: text.gsub(/&#x2af7;.*&#x2af8;/, ""): from the first opener to
+    # the last closer after it. The encoded text has no newlines.
+    def remove_comment(text)
+      start = text.index(COMMENT_OPEN) or return text
+      close = text.rindex(COMMENT_CLOSE)
+      return text unless close && close >= start + COMMENT_OPEN.length
+
+      text[0...start] + text[(close + COMMENT_CLOSE.length)..]
+    end
+
+    def encode(text)
+      text = text.gsub(BASIC) { |char| hex(char) }
+      text.gsub(EXTENDED) { |char| hex(char) }
+    end
+
+    def hex(char)
+      "&#x#{char.ord.to_s(16)};"
+    end
+
+    private_class_method :split_label, :protect_pen_group, :remove_comment, :encode, :hex
+  end
+end

data/lib/umath/raw_parser.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Umath
+  # The internal raw-tree boundary: the legacy preprocessing, then the
+  # grammar, then the declared syntax bindings, which carry the raw tree.
+  #
+  # Internal and for tests and parity replay only; not public API. The
+  # public Umath.parse, which returns the typed language model, is
+  # built on top of it.
+  module RawParser
+    # +text+: the grammar input (see Preprocessor::Result), nil when the
+    # input has no formula part; +label+/+labeled+: the label split off by
+    # preprocessing; +tree+: the raw tree of the normalized grammar (Hashes,
+    # Arrays and Parsanol::Slice leaves; scripts/unwrap.rb turns it into the
+    # legacy tree), nil when +text+ is nil; +model_data+: the same
+    # tree as plain Hashes, Arrays and Strings with String keys (the typed
+    # model's construction input); +engine+: the engine that produced it.
+    Result = Struct.new(:text, :label, :labeled, :tree, :model_data, :engine, keyword_init: true)
+
+    module_function
+
+    def parse(input, decimal: ".", engine: :ruby)
+      entry = entry_for(decimal)
+      mode = Engine.resolve(engine)
+      pre = Preprocessor.call(normalize_input(input))
+      result = Result.new(text: pre.text, label: pre.label, labeled: pre.labeled)
+      return result if pre.text.nil?
+
+      loaded = Umath.artifacts
+      shape = Engine.run(loaded.parse, entry, pre.text, mode, fallback: engine == :auto)
+      bound = loaded.bindings.apply(entry, shape)
+      result.tree, result.model_data = [Configuration::TREE_CAPTURE, Configuration::MODEL_BINDING].map do |key|
+        bound.fetch(key) { raise ArtifactError, "the declared bindings did not produce #{key}" }
+      end
+      result.engine = Engine.last_engine
+      result
+    end
+
+    def entry_for(decimal)
+      Configuration::DECIMAL_ENTRIES.fetch(decimal) do
+        raise ArgumentError,
+              "unsupported decimal marker #{decimal.inspect} " \
+              "(supported: #{Configuration::DECIMAL_ENTRIES.keys.map(&:inspect).join(', ')})"
+      end
+    end
+
+    # +input+ as valid UTF-8, or an ArgumentError.
+    def normalize_input(input)
+      raise ArgumentError, "input must be a String, got #{input.class}" unless input.is_a?(String)
+
+      text = input.encoding == Encoding::UTF_8 ? input : input.encode(Encoding::UTF_8)
+      raise ArgumentError, "input is not valid UTF-8" unless text.valid_encoding?
+
+      text
+    rescue EncodingError => e
+      raise ArgumentError, "input cannot be converted to UTF-8: #{e.message}"
+    end
+  end
+end

data/lib/umath/source_map.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+module Umath
+  # Maps positions in the grammar input back to the caller's text.
+  #
+  # The grammar runs on the preprocessed text (Preprocessor), which differs
+  # from the caller's: non-ASCII characters become character references, a
+  # comment and the label are removed, escapes are folded. SourceMap repeats
+  # each Preprocessor step on the caller's text while recording, for every
+  # character it produces, the caller character it came from. A step that
+  # replaces a match gives every produced character the position of the
+  # match's first character.
+  #
+  # Internal: the public parser uses it to report ParseError offsets in the
+  # caller's text.
+  class SourceMap
+    attr_reader :text
+
+    # +input+: the caller's text as valid UTF-8.
+    def self.build(input)
+      new(input)
+    end
+
+    def initialize(input)
+      @input = input
+      chars, origins = formula(input)
+      chars, origins = encode(chars, origins)
+      text = chars.join
+      text, origins = replace(text, origins, "&") { "&" }
+      text, origins = replace(text, origins, """) { "\"" }
+      text, origins = remove_comment(text, origins)
+      text, origins = replace(text, origins, "\\\\") { "\\" }
+      text, origins = replace(text, origins, Preprocessor::U_ESCAPE) { |m| "&#x#{m[1]};" }
+      @text, @origins = strip(text, origins)
+    end
+
+    # The caller position, as [char_offset, byte_offset], of grammar input
+    # character +char_offset+ (the end of the grammar input maps to the end
+    # of the formula part of the caller's text).
+    def caller_position(char_offset)
+      char = if char_offset < @origins.size
+               @origins[char_offset]
+             elsif @origins.empty?
+               @text_end || 0
+             else
+               @origins.last + 1
+             end
+      [char, @input[0, char].bytesize]
+    end
+
+    private
+
+    # The formula part as characters with their caller positions:
+    # Preprocessor.split_label with the protection of "#" inside ✎(...)
+    # undone by position.
+    def formula(input)
+      chars = []
+      origins = []
+      position = 0
+      input.split("\n", -1).each_with_index do |line, index|
+        unless index.zero?
+          chars << "\n"
+          origins << (position - 1)
+        end
+        protected_line = protect(line)
+        protected_line.each { |c, offset| chars << c; origins << (position + offset) }
+        position += line.length + 1
+      end
+      text = chars.join
+      cut = text.index("#") || text.length
+      chars = chars.first(cut)
+      origins = origins.first(cut)
+      @text_end = cut.zero? ? 0 : nil
+      text, origins = replace(chars.join, origins, Preprocessor::PROTECTED_HASH) { "#" }
+      [text.chars, origins]
+    end
+
+    # The line's characters with their offsets in it; a protected "#"
+    # becomes Preprocessor::PROTECTED_HASH, every character of which keeps
+    # the "#"'s offset.
+    def protect(line)
+      chars = line.chars.each_with_index.to_a
+      protected_text = Preprocessor.send(:protect_pen_group, line)
+      return chars if protected_text == line
+
+      start = line.index(Preprocessor::PEN_OPEN)
+      close = line.rindex(")")
+      chars.flat_map do |c, offset|
+        if c == "#" && offset > start && offset < close
+          Preprocessor::PROTECTED_HASH.chars.map { |p| [p, offset] }
+        else
+          [[c, offset]]
+        end
+      end
+    end
+
+    def encode(chars, origins)
+      out = []
+      out_origins = []
+      chars.each_with_index do |c, i|
+        piece = c.match?(Preprocessor::BASIC) || c.match?(Preprocessor::EXTENDED) ? "&#x#{c.ord.to_s(16)};" : c
+        piece.each_char { |p| out << p; out_origins << origins[i] }
+      end
+      [out, out_origins]
+    end
+
+    def replace(text, origins, pattern)
+      regexp = pattern.is_a?(Regexp) ? pattern : Regexp.new(Regexp.escape(pattern))
+      out = +""
+      out_origins = []
+      last = 0
+      text.scan(regexp) do
+        match = Regexp.last_match
+        from, to = match.offset(0)
+        out << text[last...from]
+        out_origins.concat(origins[last...from])
+        piece = yield(match)
+        out << piece
+        out_origins.concat([origins[from]] * piece.length)
+        last = to
+      end
+      out << text[last..]
+      out_origins.concat(origins[last..])
+      [out, out_origins]
+    end
+
+    def remove_comment(text, origins)
+      start = text.index(Preprocessor::COMMENT_OPEN) or return [text, origins]
+      close = text.rindex(Preprocessor::COMMENT_CLOSE)
+      return [text, origins] unless close && close >= start + Preprocessor::COMMENT_OPEN.length
+
+      stop = close + Preprocessor::COMMENT_CLOSE.length
+      [text[0...start] + text[stop..], origins[0...start] + origins[stop..]]
+    end
+
+    # String#strip: leading whitespace, trailing whitespace and NULs.
+    def strip(text, origins)
+      stripped = text.strip
+      return [text, origins] if stripped.length == text.length
+
+      lead = text.length - text.lstrip.length
+      @text_end ||= origins[lead] if stripped.empty?
+      [stripped, origins[lead, stripped.length]]
+    end
+  end
+end

data/lib/umath/symbols.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Umath
+  # Symbol resolution: the separate pass after model construction that
+  # gives every Model::MathSymbol its Unicode value and kind from the
+  # exported symbol catalog (data/umath-symbols.json, written by
+  # scripts/export_symbols.rb from the pinned Plurimath commit).
+  #
+  # Lookup is the legacy one: the spelling with surrounding whitespace
+  # removed, exactly as the grammar matched it.
+  module Symbols
+    FORMAT = "umath-symbol-catalog/1"
+    CHARACTER_REFERENCE = /&#(?:x(\h{1,6})|(\d{1,7}));/
+
+    @catalog = nil
+    @lock = Mutex.new
+
+    module_function
+
+    # The catalog: spelling => [value, kind].
+    def catalog
+      @lock.synchronize { @catalog ||= load(Configuration::SYMBOLS_PATH) }
+    end
+
+    def load(path)
+      doc = JSON.parse(File.read(path, encoding: "UTF-8"))
+      raise ArtifactError, "symbol catalog #{path} has format #{doc['format'].inspect}, not #{FORMAT}" unless doc["format"] == FORMAT
+
+      doc.fetch("symbols").transform_values { |entry| [entry.fetch("value").freeze, entry.fetch("kind").freeze].freeze }.freeze
+    rescue SystemCallError, JSON::ParserError, KeyError, TypeError, NoMethodError => e
+      raise ArtifactError, "symbol catalog #{path} cannot be used: #{e.class}: #{e.message.lines.first&.strip}"
+    end
+
+    # [value, kind] for +spelling+.
+    def lookup(spelling)
+      catalog.fetch(spelling.strip) { [decode(spelling), "unlisted"] }
+    end
+
+    # Fills value and kind of every node under +node+ (a model instance)
+    # that holds a spelling: each Model::MathSymbol, and the symbol nodes
+    # (SymbolNode, OpenParen, ...) whose text the grammar captured as
+    # spelling. Iterative over the declared attributes; returns +node+.
+    def resolve(node)
+      stack = [node]
+      until stack.empty?
+        current = stack.pop
+        attributes = current.class.attributes
+        current.value, current.kind = lookup(current.spelling) if attributes.key?(:spelling) && current.spelling
+        attributes.each_key do |name|
+          value = current.public_send(name)
+          case value
+          when Lutaml::Model::Serializable then stack << value
+          when ::Array then value.each { |v| stack << v if v.is_a?(Lutaml::Model::Serializable) }
+          end
+        end
+      end
+      node
+    end
+
+    # +text+ with its numeric character references decoded.
+    def decode(text)
+      text.gsub(CHARACTER_REFERENCE) do
+        code = ::Regexp.last_match(1) ? ::Regexp.last_match(1).to_i(16) : ::Regexp.last_match(2).to_i
+        valid = code <= 0x10FFFF && !(0xD800..0xDFFF).cover?(code)
+        valid ? [code].pack("U") : ::Regexp.last_match(0)
+      end
+    end
+  end
+end

data/lib/umath/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Umath
+  VERSION = "0.1.0"
+end

data/lib/umath.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require "parsanol"
+
+# UnicodeMath parser backed by a compiled Parsanol (PARG) grammar artifact.
+#
+# Umath.parse returns the typed language model (Umath::Model,
+# declared with LutaML Model). The raw parse tree (Umath::RawParser)
+# is an internal boundary for parity replay with the legacy Plurimath
+# parser. See docs/parser-contract.adoc and docs/model-contract.adoc.
+module Umath
+  autoload :VERSION, "umath/version"
+  autoload :Error, "umath/errors"
+  autoload :ParseError, "umath/errors"
+  autoload :NestingTooDeep, "umath/errors"
+  autoload :ArtifactError, "umath/errors"
+  autoload :EngineUnavailable, "umath/errors"
+  autoload :Artifact, "umath/artifact"
+  autoload :Configuration, "umath/configuration"
+  autoload :Engine, "umath/engine"
+  autoload :Preprocessor, "umath/preprocessor"
+  autoload :RawParser, "umath/raw_parser"
+  autoload :Parser, "umath/parser"
+  autoload :Model, "umath/model"
+  autoload :SourceMap, "umath/source_map"
+  autoload :Symbols, "umath/symbols"
+
+  @artifacts = Artifact.new(Configuration::DEFAULT_ARTIFACT_PATH,
+                            Configuration::DEFAULT_BINDINGS_PATH)
+
+  class << self
+    # Parses +input+ (a String) and returns its Umath::Model::Document.
+    #
+    # +decimal+: the decimal marker, "." (default), "," or "٫" (U+066B).
+    # +engine+: :ruby (default), :native, or :auto (native where available,
+    # else Ruby).
+    #
+    # Raises ParseError (with offsets into +input+) when the input is
+    # refused, NestingTooDeep when the selected engine cannot handle its
+    # depth, EngineUnavailable for an unavailable engine: :native,
+    # ArtifactError for unusable bundled artifacts and ArgumentError for
+    # invalid arguments.
+    def parse(input, decimal: ".", engine: :ruby)
+      Parser.parse(input, decimal: decimal, engine: engine)
+    end
+
+    # The engine (:native or :ruby) of this thread's last parse or
+    # rejection, nil before any.
+    def last_engine
+      Engine.last_engine
+    end
+
+    # The verified, paired parse and Ruby bindings artifacts (internal).
+    def artifacts
+      @artifacts.fetch
+    end
+
+    # Points Umath at other artifacts (for tests). The next parse
+    # loads and verifies them.
+    def use_artifacts(path, bindings_path)
+      @artifacts.use(path, bindings_path)
+    end
+
+    def artifact_paths
+      [@artifacts.path, @artifacts.bindings_path]
+    end
+  end
+end
+
+# Installs a hook into Parsanol at load time, so it is required, not
+# autoloaded.
+require_relative "umath/errors"
+require_relative "umath/native_recursion_guard"

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification
+name: umath
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Ribose Inc.
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: lutaml-model
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.8.162
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.8.162
+- !ruby/object:Gem::Dependency
+  name: parsanol
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.131
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.131
+description: |
+  UnicodeMath parser extracted from Plurimath: a compiled Parsanol grammar
+  whose parse result is a typed UnicodeMath model declared with LutaML
+  Model.
+email:
+- open.source@ribose.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.md
+- README.adoc
+- artifacts/umath.bindings.ruby.json
+- artifacts/umath.json
+- data/umath-symbols.json
+- docs/model-contract.adoc
+- docs/parser-contract.adoc
+- docs/testsuite-pin.adoc
+- lib/umath.rb
+- lib/umath/artifact.rb
+- lib/umath/configuration.rb
+- lib/umath/engine.rb
+- lib/umath/errors.rb
+- lib/umath/model.rb
+- lib/umath/model/nodes.rb
+- lib/umath/native_recursion_guard.rb
+- lib/umath/parser.rb
+- lib/umath/preprocessor.rb
+- lib/umath/raw_parser.rb
+- lib/umath/source_map.rb
+- lib/umath/symbols.rb
+- lib/umath/version.rb
+homepage: https://github.com/plurimath/umath
+licenses:
+- BSD-2-Clause
+metadata:
+  homepage_uri: https://github.com/plurimath/umath
+  source_code_uri: https://github.com/plurimath/umath
+  changelog_uri: https://github.com/plurimath/umath/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.23
+specification_version: 4
+summary: UnicodeMath parser by Plurimath.
+test_files: []