plurimath 0.11.14 → 0.11.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4dff71324c05914fedf2b52ffb81380cab155c6712986754d3c365801f444487
-  data.tar.gz: aa29dddcb9ebf1605330592c798319e239ad8ccd0fb27c4f9c1be3f97351451c
+  metadata.gz: 4b65c30f11725ec42f14fe121fda3a4d3398baedf7b5442a3f87bd9cffe95573
+  data.tar.gz: 60908df104d07d036963dc5c105e0f02fb4b65a0f0336f4e21941ff5f080cef5
 SHA512:
-  metadata.gz: 395210b0ec883f560c5e575ead3aa55482a32e02e88fe3455b6df276cc32d4ec589b3baf6770f80cb43aec910e9ecacf4363089bfdae50eefe013280e1219729
-  data.tar.gz: 7f56f2e6f2983193fe5ea9884395c228ce3816b4725ab401fb6d3d4433fa9cdeb9530f3b015d3bf389e5eaf14f8769bd40ede313bf3a230f8219d0c7534ff9aa
+  metadata.gz: 9c4e43105945034eb0079c6d72ef9cd8593c318b12544781328547647445589808c6faef7a3e813f3c532a59d54d59a13827fa034e1496932b67c4dd95508b6f
+  data.tar.gz: 58ee38130ab763b8733f9602b07d07648605918ae1c7e7a4bb49f9d7e0fb867f45f3e062cb6837b385331e95e782ab272cfd6804b19900d4205f8f4ef4827b58

data/.github/workflows/dependent-tests.yml

@@ -20,5 +20,5 @@ jobs:
         git init ../amath
         git -C ../amath fetch --depth 1 https://github.com/plurimath/amath.git b67f924477ce129e85926eda5973d771c007dfec
         git -C ../amath checkout --detach FETCH_HEAD
-        printf '\ngem "amath", path: "../amath"\ngem "parsanol", "~> 1.3", ">= 1.3.112"\n' >> Gemfile
+        printf '\ngem "amath", path: "../amath"\n' >> Gemfile
       repos-json-file: .github/workflows/dependent-repos-ruby.json

data/.rspec-opal

@@ -4,6 +4,7 @@
 -q ll/setup_opal
 --opal-opt=-g,htmlentities
 --opal-opt=-g,parslet
+--opal-opt=-g,parsanol
 --opal-opt=-g,canon
 --opal-opt=-g,oga
 --format documentation

data/Gemfile

@@ -4,6 +4,7 @@ source "https://rubygems.org"
 gemspec
 
 gem "canon"
+gem "leptris" # third XML engine under test (spec_helper runs each example per engine)
 # Optional native image-rendering backend for `Formula#render` / `plurimath
 # render`. Git-pinned until `lasem` ships to RubyGems; intentionally NOT a
 # gemspec runtime dependency so Opal/plurimath-js and lasem-less installs keep
@@ -17,9 +18,7 @@ gem "nokogiri"
 # gem "omml", github: "plurimath/omml", branch: "main"
 gem "opal-rspec", "~> 1.1.0a"
 gem "ox"
-# Parsanol::Slice for the amath SliceAdapter specs.
-# 1.3.112 restores the v1 edition default (1.3.110 and 1.3.111 are yanked).
-gem "parsanol", "~> 1.3", ">= 1.3.112"
+gem "parsanol"
 gem "rake", "~> 12.0"
 gem "rspec", "~> 3.0"
 gem "rubocop-performance"

data/lib/plurimath/cli/helpers.rb

@@ -32,8 +32,11 @@ module Plurimath
                        when "oga"
                          require_relative "../setup/oga"
                          Plurimath::XmlEngine::Oga
+                       when "leptris"
+                         require_relative "../setup/leptris_engine"
+                         Plurimath::XmlEngine::LeptrisEngine
                        else
-                         warn_and_exit("Invalid XML engine: #{engine}. Use 'ox' or 'oga'.")
+                         warn_and_exit("Invalid XML engine: #{engine}. Use 'ox', 'oga' or 'leptris'.")
                        end
         Plurimath.xml_engine = engine_class
       end

data/lib/plurimath/cli.rb

@@ -51,7 +51,7 @@ module Plurimath
     option :xml_engine,
            aliases: "-e",
            default: "ox",
-           desc: "XML engine to use for parsing and rendering (ox or oga)"
+           desc: "XML engine to use for parsing and rendering (ox, oga or leptris)"
 
     def convert
       Convert.new(options).call
@@ -101,7 +101,7 @@ module Plurimath
     option :xml_engine,
            aliases: "-e",
            default: "ox",
-           desc: "XML engine to use for parsing and rendering (ox or oga)"
+           desc: "XML engine to use for parsing and rendering (ox, oga or leptris)"
 
     def render
       Render.new(options).call

data/lib/plurimath/html/parse.rb

@@ -2,7 +2,7 @@
 
 module Plurimath
   class Html
-    class Parse < Parslet::Parser
+    class Parse < Parsanol::Parser
       include Plurimath::BaseNumberPrefix::Parser
 
       rule(:space)   { match["\s"].repeat(1) }

data/lib/plurimath/html/parser.rb

@@ -15,7 +15,7 @@ module Plurimath
 
       def parse
         nodes = Parse.new.parse(normalized_text)
-        nodes = JSON.parse(nodes.to_json, symbolize_names: true)
+        nodes = JSON.parse(normalized_nodes(nodes).to_json, symbolize_names: true)
         transformed_tree = Transform.new.apply(nodes)
         return transformed_tree if transformed_tree.is_a?(Math::Formula)
 
@@ -24,6 +24,19 @@ module Plurimath
 
       private
 
+      def normalized_nodes(node, depth = 0)
+        if depth >= 100 && (node.is_a?(Hash) || node.is_a?(Array))
+          raise JSON::NestingError, "nesting of #{depth + 1} is too deep"
+        end
+
+        case node
+        when Parsanol::Slice then node.to_s
+        when Hash then node.transform_values { |child| normalized_nodes(child, depth + 1) }
+        when Array then node.map { |child| normalized_nodes(child, depth + 1) }
+        else node
+        end
+      end
+
       def normalized_text
         text.gsub(HTML_ENTITY) do |entity|
           decoded_entity = Utility.html_entity_to_unicode(entity)

data/lib/plurimath/html/transform.rb

@@ -2,7 +2,7 @@
 
 module Plurimath
   class Html
-    class Transform < Parslet::Transform
+    class Transform < Parsanol::Transform
       include Plurimath::BaseNumberPrefix::Transform
 
       rule(text: simple(:text))      { Math::Function::Text.new(text) }

data/lib/plurimath/latex/parse.rb

@@ -2,9 +2,13 @@
 
 module Plurimath
   class Latex
-    class Parse < Parslet::Parser
+    class Parse < Parsanol::Parser
       include Plurimath::BaseNumberPrefix::Parser
 
+      def parse(input, options = {}, **kwargs)
+        restore_row_break_keys(super)
+      end
+
       rule(:base)          { str("_") }
       rule(:power)         { str("^") }
       rule(:slash)         { str("\\") }
@@ -276,6 +280,21 @@ module Plurimath
         (str("{") >> slash >> str("color").as(:binary) >> color.as(:first_value) >> (sequence >> iteration.maybe).as(:second_value).maybe >> str("}")) |
           (slash >> str("color").as(:binary) >> color.as(:first_value) >> expression.as(:second_value).maybe)
       end
+
+      private
+
+      # Native captures use Symbol names; this grammar historically names its
+      # row-break capture with a String. Preserve that public raw-tree shape.
+      def restore_row_break_keys(tree)
+        case tree
+        when Hash
+          tree.to_h do |key, value|
+            [key == :"\\\\" ? "\\\\" : key, restore_row_break_keys(value)]
+          end
+        when Array then tree.map { |value| restore_row_break_keys(value) }
+        else tree
+        end
+      end
     end
   end
 end

data/lib/plurimath/latex/transform.rb

@@ -2,7 +2,7 @@
 
 module Plurimath
   class Latex
-    class Transform < Parslet::Transform
+    class Transform < Parsanol::Transform
       include Plurimath::BaseNumberPrefix::Transform
 
       rule(base: simple(:base))       { base }
@@ -25,6 +25,8 @@ module Plurimath
       end
       rule(limits: simple(:limits))   { limits }
       rule("\\\\" => simple(:slash))  { Math::Function::Linebreak.new }
+      # Native named captures use symbol keys; Ruby retains the declared string.
+      rule("\\\\": simple(:slash)) { Math::Function::Linebreak.new }
       rule(expression: simple(:expr)) { expr }
       rule(environment: simple(:env)) { env }
       rule(ternary: simple(:ternary)) { Utility.get_class(ternary).new }
@@ -52,7 +54,7 @@ module Plurimath
       end
 
       rule(binary: simple(:binary)) do
-        binary.is_a?(Parslet::Slice) ? Utility.get_class(binary).new : binary
+        binary.is_a?(Parsanol::Slice) ? Utility.get_class(binary).new : binary
       end
 
       rule(symbols: simple(:sym)) do
@@ -330,7 +332,7 @@ module Plurimath
 
       rule(unary_functions: simple(:unary),
            subscript: simple(:subscript)) do
-        unary_function = if unary.is_a?(Parslet::Slice)
+        unary_function = if unary.is_a?(Parsanol::Slice)
                            Utility.get_class(unary).new
                          else
                            unary
@@ -356,7 +358,7 @@ module Plurimath
 
       rule(unary_functions: simple(:unary),
            supscript: simple(:supscript)) do
-        unary_function = if unary.is_a?(Parslet::Slice)
+        unary_function = if unary.is_a?(Parsanol::Slice)
                            Utility.get_class(unary).new
                          else
                            unary
@@ -389,7 +391,7 @@ module Plurimath
       rule(unary_functions: simple(:unary),
            subscript: simple(:subscript),
            supscript: simple(:supscript)) do
-        unary_function = if unary.is_a?(Parslet::Slice)
+        unary_function = if unary.is_a?(Parsanol::Slice)
                            Utility.get_class(unary).new
                          else
                            unary
@@ -756,7 +758,7 @@ module Plurimath
       rule(binary: simple(:binary),
            subscript: simple(:subscript),
            supscript: simple(:supscript)) do
-        if binary.is_a?(Parslet::Slice)
+        if binary.is_a?(Parsanol::Slice)
           Utility.get_class(binary).new(
             subscript,
             supscript,
@@ -772,7 +774,7 @@ module Plurimath
 
       rule(binary: simple(:binary),
            subscript: simple(:subscript)) do
-        if binary.is_a?(Parslet::Slice)
+        if binary.is_a?(Parsanol::Slice)
           Utility.get_class(binary).new(subscript)
         else
           Math::Function::Base.new(

data/lib/plurimath/math/function/unary_function.rb

@@ -11,7 +11,7 @@ module Plurimath
         attr_accessor :parameter_one, :hide_function_name
 
         def initialize(parameter_one = nil)
-          parameter_one  = parameter_one.to_s if parameter_one.is_a?(Parslet::Slice)
+          parameter_one  = parameter_one.to_s if Utility.parser_slice?(parameter_one)
           @parameter_one = parameter_one
           method(:post_initialize).call if methods.include?(:post_initialize)
           ModelHelper.validate_left_right(variables.map { |var| get(var) })

data/lib/plurimath/math/number.rb

@@ -7,7 +7,7 @@ module Plurimath
 
       def initialize(value = nil, mini_sub_sized: false, mini_sup_sized: false,
                      base: nil)
-        @value = value.is_a?(::Parslet::Slice) ? value.to_s : value
+        @value = Utility.parser_slice?(value) ? value.to_s : value
         @mini_sub_sized = mini_sub_sized
         @mini_sup_sized = mini_sup_sized
         @base = base

data/lib/plurimath/setup/leptris_engine.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+begin
+  require "leptris"
+rescue LoadError
+  raise LoadError,
+        "the leptris XML engine needs the leptris gem " \
+        "(gem install leptris, or add `gem \"leptris\"` to your Gemfile). " \
+        "leptris is an opt-in soft dependency, like the oga engine."
+end
+
+require "plurimath/xml_engine/leptris_engine"
+
+Plurimath.xml_engine = Plurimath::XmlEngine::LeptrisEngine

data/lib/plurimath/unicode_math/parse.rb

@@ -2,7 +2,7 @@
 
 module Plurimath
   class UnicodeMath
-    class Parse < Parslet::Parser
+    class Parse < Parsanol::Parser
       include Plurimath::BaseNumberPrefix::Parser
       include ParsingRules::Masked
       include ParsingRules::SubSup
@@ -10,6 +10,11 @@ module Plurimath
       include ParsingRules::ConstantsRules
       include ParsingRules::AbsenceRules
 
+      # Preserve the historical UnicodeMath memo decisions in both engines.
+      def parse(input, options = {}, **kwargs)
+        super(input, options, **kwargs, compatibility: :parslet)
+      end
+
       rule(:an)  { an_math | an_other }
       rule(:box) { str("□") >> operand }
 
@@ -288,7 +293,7 @@ module Plurimath
       root :expression
 
       def decimal_marker
-        # UnicodeMath::Parser entity-encodes input before Parslet sees it, so
+        # UnicodeMath::Parser entity-encodes input before the grammar sees it, so
         # non-ASCII locale markers must match that encoded parser input.
         str(Utility.string_to_html_entity(Plurimath.configuration.decimal))
       end

data/lib/plurimath/unicode_math/parsing_rules/helper.rb

@@ -5,13 +5,7 @@ module Plurimath
     module ParsingRules
       module Helper
         def self.included(base)
-          base.extend(ClassMethods)
-        end
-      end
-
-      module ClassMethods
-        def rule(name, &block)
-          Parslet::Parser.rule(name, &block)
+          base.extend(Parsanol::ClassMethods)
         end
       end
     end

data/lib/plurimath/unicode_math/transform.rb

@@ -2,7 +2,7 @@
 
 module Plurimath
   class UnicodeMath
-    class Transform < Parslet::Transform
+    class Transform < Parsanol::Transform
       include Plurimath::BaseNumberPrefix::Transform
 
       rule(td: simple(:td)) { Math::Function::Td.new([td]) }

data/lib/plurimath/utility.rb

@@ -132,6 +132,10 @@ module Plurimath
     }.freeze
 
     class << self
+      def parser_slice?(value)
+        value.is_a?(::Parslet::Slice) || value.is_a?(::Parsanol::Slice)
+      end
+
       def get_table_class(text)
         Object.const_get("Plurimath::Math::Function::Table::#{capitalize(text)}")
       end
@@ -210,7 +214,7 @@ module Plurimath
       end
 
       def symbols_class(string, lang:, table: false)
-        return string unless string.is_a?(String) || string.is_a?(Parslet::Slice)
+        return string unless string.is_a?(String) || parser_slice?(string)
         return latex_table_curly_paren(string) if table && lang == :latex
 
         all_symbols_classes(lang)[string.to_s.strip]&.new ||

data/lib/plurimath/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Plurimath
-  VERSION = "0.11.14"
+  VERSION = "0.11.15"
 end

data/lib/plurimath/xml_engine/leptris_engine/element.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+module Plurimath
+  module XmlEngine
+    class LeptrisEngine
+      class Element
+        # strip_prefix mirrors ox's strip_namespace: names of a document
+        # loaded via LeptrisEngine.load report local names, while elements
+        # constructed by name keep their prefix ("w:rPr").
+        def initialize(node, strip_prefix: false)
+          @strip_prefix = strip_prefix
+          @node =
+            if node.is_a?(String)
+              # leptris parses namespace prefixes leniently, so prefixed names
+              # (w:rPr et al.) need no declaration; keep the owning document
+              # reachable so the FFI handle outlives this wrapper.
+              fragment = ::Leptris::XML.parse("<#{node}/>")
+              @document = fragment
+              fragment.root
+            else
+              @document = node.document if node.respond_to?(:document)
+              node
+            end
+          # The parser reports local names (prefix stripped) while the tree
+          # keeps the prefix in serialization; restore the constructed
+          # spelling so #name matches the ox contract ("w:rPr", not "rPr").
+          @node.name = node if node.is_a?(String) && @node.name != node
+        end
+
+        def ==(object)
+          self.class == object.class &&
+            @node.to_xml == object.xml_nodes.to_xml
+        end
+
+        def [](object)
+          # leptris's own #[] lookup is namespace-aware and misses prefixed
+          # names; the attributes hash keeps the constructed spelling, which
+          # matches ox's flat string keys.
+          @node.attributes[object.to_s]&.value
+        end
+
+        def []=(attr, value)
+          @node[attr.to_s] = Utility.html_entity_to_unicode(value.to_s)
+        end
+
+        def name
+          local = @node.name
+          return local if @strip_prefix || local.include?(":")
+
+          # attached nodes report only the local name; re-attach the prefix
+          # the tree still carries for the constructed-name contract
+          prefix = @node.prefix
+          prefix ? "#{prefix}:#{local}" : local
+        end
+
+        def name=(new_name)
+          @node.name = new_name
+        end
+
+        def set_attr(attrs)
+          attrs&.each { |key, value| self[key] = value }
+          self
+        end
+
+        def remove_attr(attribute)
+          @node.remove_attribute(attribute.to_s)
+        end
+
+        def <<(object)
+          @node.add_child(
+            object.is_a?(String) ? text_node_for(object) : attachable(object.xml_nodes),
+          )
+          self
+        end
+
+        def attributes
+          @node.attributes.transform_values(&:value)
+        end
+
+        def attributes=(attr_hash = {})
+          set_attr(attr_hash)
+        end
+
+        def xml_nodes
+          @node
+        end
+
+        def nodes
+          @node.children.map { |node| element_or_string(node) }
+        end
+
+        def each(&block)
+          nodes.each(&block)
+        end
+
+        def map(&block)
+          nodes.map(&block)
+        end
+
+        def xml_node?
+          true
+        end
+
+        def insert_in_nodes(index, element)
+          children = @node.children
+          node = attachable(element.xml_nodes)
+          if index >= children.size
+            @node.add_child(node)
+          else
+            children[index].add_previous_sibling(node)
+          end
+          self
+        end
+
+        # Ox-style locate paths ("*/mfrac/@intent") are XPath-compatible once
+        # made relative; attribute results come back as plain strings, as
+        # Ox's locate returns them.
+        def locate(string)
+          @node.xpath("./#{string}").map do |found|
+            case found
+            when ::Leptris::XML::Attr then found.value
+            when ::Leptris::XML::Text then found.text
+            else self.class.new(found, strip_prefix: @strip_prefix)
+            end
+          end
+        end
+
+        def replace_nodes(nodes_array)
+          @node.children.each(&:unlink)
+          nodes_array.each do |node|
+            @node.add_child(
+              if node.is_a?(Element)
+                attachable(node.xml_nodes)
+              elsif node.is_a?(String)
+                text_node_for(node)
+              else
+                attachable(node)
+              end,
+            )
+          end
+          self
+        end
+
+        def is_xml_comment?
+          @node.is_a?(::Leptris::XML::Comment)
+        end
+
+        private
+
+        # Engine insertion has value semantics: ox and oga let the same
+        # element object be inserted twice and render twice (Abs relies on
+        # this for its open/close fences). leptris nodes are handles into a
+        # C tree where a second add_child MOVES the node, so an
+        # already-attached node is deep-copied first; freshly built nodes
+        # (no parent yet) attach directly.
+        def attachable(node)
+          return node unless node.parent
+
+          if node.is_a?(::Leptris::XML::Element)
+            node.dup
+          else
+            # dup is only supported for element nodes; rebuild text by value
+            text_node_for(node.text)
+          end
+        end
+
+        # Ox stores string children raw (no markup decoding); leptris treats
+        # add_child(String) as markup, so go through create_text_node to keep
+        # entity text like "&#x3b2;" literal.
+        def text_node_for(string)
+          doc = @node.respond_to?(:document) ? @node.document : @node
+          doc.create_text_node(string)
+        end
+
+        def element_or_string(node)
+          node.is_a?(::Leptris::XML::Text) ? node.text : self.class.new(node, strip_prefix: @strip_prefix)
+        end
+      end
+    end
+  end
+end

data/lib/plurimath/xml_engine/leptris_engine.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "leptris"
+
+module Plurimath
+  module XmlEngine
+    class LeptrisEngine
+      class << self
+        def new_element(name)
+          Element.new(name)
+        end
+
+        def dump(data, indent: nil)
+          # ox dump parity: compact when indent is nil, 2-space pretty print
+          # otherwise; ox additionally wraps the output in newlines — the
+          # leading one is stripped by REPLACABLES downstream, the trailing
+          # one is part of the expected output, so it is appended here.
+          xml = data.xml_nodes.to_xml(indent: indent)
+          indent ? "#{xml}\n" : xml
+        end
+
+        def load(data)
+          Element.new(::Leptris::XML.parse(data), strip_prefix: true)
+        end
+
+        def is_xml_comment?(node)
+          return node.is_xml_comment? if node.is_a?(Element)
+
+          false
+        end
+
+        def replace_nodes(root, nodes)
+          root.replace_nodes(Array(nodes))
+          root
+        end
+      end
+
+      autoload :Element, "#{__dir__}/leptris_engine/element"
+    end
+  end
+end

data/lib/plurimath.rb

@@ -1,5 +1,6 @@
 require "mml"
 require "parslet"
+require "parsanol"
 require "htmlentities"
 
 # Select an XML engine
@@ -64,6 +65,9 @@ default_adapter =
     require "plurimath/setup/oga"
     require "plurimath/setup/opal"
     :oga
+  elsif ENV["PLURIMATH_LEPTRIS"]
+    require "plurimath/setup/leptris_engine"
+    :leptris
   elsif ENV["PLURIMATH_OGA"]
     require "plurimath/setup/oga"
     :oga

data/plurimath.gemspec

@@ -35,6 +35,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency "omml", "~> 0.2.5"
   spec.add_dependency "ostruct"
   spec.add_dependency "ox"
+  spec.add_dependency "parsanol", "~> 1.3", ">= 1.3.116"
   spec.add_dependency "parslet"
   spec.add_dependency "thor"
   spec.add_dependency "unitsml", "~> 0.6.4"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: plurimath
 version: !ruby/object:Gem::Version
-  version: 0.11.14
+  version: 0.11.15
 platform: ruby
 authors:
 - Ribose Inc.
@@ -122,6 +122,26 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !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.116
+  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.116
 - !ruby/object:Gem::Dependency
   name: parslet
   requirement: !ruby/object:Gem::Requirement
@@ -1918,6 +1938,7 @@ files:
 - lib/plurimath/omml/parser.rb
 - lib/plurimath/omml/translator.rb
 - lib/plurimath/omml/utility.rb
+- lib/plurimath/setup/leptris_engine.rb
 - lib/plurimath/setup/oga.rb
 - lib/plurimath/setup/opal.rb.erb
 - lib/plurimath/setup/ox_engine.rb
@@ -1940,6 +1961,8 @@ files:
 - lib/plurimath/utility/intent_encoding.rb
 - lib/plurimath/version.rb
 - lib/plurimath/xml_engine.rb
+- lib/plurimath/xml_engine/leptris_engine.rb
+- lib/plurimath/xml_engine/leptris_engine/element.rb
 - lib/plurimath/xml_engine/oga.rb
 - lib/plurimath/xml_engine/oga/document.rb
 - lib/plurimath/xml_engine/oga/dumper.rb