moxml 0.1.21 → 0.1.23

data/lib/compat/opal/rexml/source.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: false
+
+require "stringio"
+require "strscan"
+
+require "rexml/encoding"
+
+module REXML
+  if defined?(StringScanner::Version) && StringScanner::Version < "1.0.0"
+    module StringScannerCheckScanString
+      refine StringScanner do
+        def check(pattern)
+          pattern = /#{Regexp.escape(pattern)}/ if pattern.is_a?(String)
+          super
+        end
+
+        def scan(pattern)
+          pattern = /#{Regexp.escape(pattern)}/ if pattern.is_a?(String)
+          super
+        end
+
+        def match?(pattern)
+          pattern = /#{Regexp.escape(pattern)}/ if pattern.is_a?(String)
+          super
+        end
+
+        def skip(pattern)
+          pattern = /#{Regexp.escape(pattern)}/ if pattern.is_a?(String)
+          super
+        end
+      end
+    end
+    using StringScannerCheckScanString
+  end
+
+  class SourceFactory
+    def self.create_from(arg)
+      if arg.respond_to?(:read) &&
+          arg.respond_to?(:readline) &&
+          arg.respond_to?(:nil?) &&
+          arg.respond_to?(:eof?)
+        if RUBY_ENGINE == "opal"
+          # Opal's StringScanner lacks <<, so use Source (full-string) instead
+          # of IOSource (streaming). Read everything upfront.
+          Source.new(arg.read, nil)
+        else
+          IOSource.new(arg)
+        end
+      elsif arg.respond_to? :to_str
+        if RUBY_ENGINE == "opal"
+          Source.new(arg, nil)
+        else
+          IOSource.new(StringIO.new(arg))
+        end
+      elsif arg.is_a? Source
+        arg
+      else
+        raise "#{arg.class} is not a valid input stream.  It must walk \nlike either a String, an IO, or a Source."
+      end
+    end
+  end
+
+  class Source
+    include Encoding
+
+    attr_reader :line, :encoding
+
+    module Private
+      SPACES_PATTERN = /\s+/
+      SCANNER_RESET_SIZE = 100000
+      PRE_DEFINED_TERM_PATTERNS = {}
+      pre_defined_terms = ["'", '"', "<", "]]>", "?>"]
+      # Opal's StringScanner requires RegExp objects, not strings.
+      pre_defined_terms.each do |term|
+        PRE_DEFINED_TERM_PATTERNS[term] = /#{Regexp.escape(term)}/
+      end
+      PRE_DEFINED_TERM_PATTERNS.freeze
+    end
+    private_constant :Private
+
+    def initialize(arg, encoding = nil)
+      @orig = arg
+      @scanner = StringScanner.new(@orig)
+      if encoding
+        self.encoding = encoding
+      else
+        detect_encoding
+      end
+      @line = 0
+      @encoded_terms = {}
+    end
+
+    def buffer
+      @scanner.rest
+    end
+
+    def drop_parsed_content
+      if @scanner.pos > Private::SCANNER_RESET_SIZE
+        @scanner = StringScanner.new(@scanner.rest)
+      end
+    end
+
+    def buffer_encoding=(encoding)
+      # no-op under Opal (no Encoding support)
+    end
+
+    def encoding=(enc)
+      return unless super
+
+      encoding_updated
+    end
+
+    def read(term = nil); end
+
+    def read_until(term)
+      pattern = Private::PRE_DEFINED_TERM_PATTERNS[term] || /#{Regexp.escape(term)}/
+      data = @scanner.scan_until(pattern)
+      unless data
+        data = @scanner.rest
+        @scanner.pos = @scanner.string.bytesize
+      end
+      data
+    end
+
+    def ensure_buffer; end
+
+    def match(pattern, cons = false)
+      pattern = Regexp.new(Regexp.escape(pattern)) if pattern.is_a?(String)
+      if cons
+        @scanner.scan(pattern).nil? ? nil : @scanner
+      else
+        @scanner.check(pattern).nil? ? nil : @scanner
+      end
+    end
+
+    def match?(pattern, cons = false)
+      pattern = Regexp.new(Regexp.escape(pattern)) if pattern.is_a?(String)
+      window = @scanner.peek(4096)
+      return false if window.empty?
+
+      m = pattern.match(window)
+      return false unless m && m.begin(0) == 0
+
+      @scanner.pos += m[0].length if cons
+      true
+    end
+
+    def skip_spaces
+      @scanner.skip(Private::SPACES_PATTERN) ? true : false
+    end
+
+    def position
+      @scanner.pos
+    end
+
+    def position=(pos)
+      @scanner.pos = pos
+    end
+
+    def peek_byte
+      @scanner.peek_byte
+    end
+
+    def scan_byte
+      @scanner.scan_byte
+    end
+
+    def empty?
+      @scanner.eos?
+    end
+
+    def current_line
+      lines = @orig.split
+      res = lines.grep @scanner.rest[0..30]
+      res = res[-1] if res.is_a? Array
+      lines.index(res) if res
+    end
+
+    private
+
+    if RUBY_ENGINE == "opal"
+      def detect_encoding
+        self.encoding = "UTF-8"
+      end
+    else
+      def detect_encoding
+        scanner_encoding = @scanner.rest.encoding
+        detected_encoding = "UTF-8"
+        begin
+          @scanner.string.force_encoding("ASCII-8BIT")
+          if @scanner.scan(/\xfe\xff/n)
+            detected_encoding = "UTF-16BE"
+          elsif @scanner.scan(/\xff\xfe/n)
+            detected_encoding = "UTF-16LE"
+          elsif @scanner.scan(/\xef\xbb\xbf/n)
+            detected_encoding = "UTF-8"
+          end
+        ensure
+          @scanner.string.force_encoding(scanner_encoding)
+        end
+        self.encoding = detected_encoding
+      end
+    end
+
+    def encoding_updated
+      if @encoding == "UTF-8"
+        @to_utf = false
+      else
+        @scanner = StringScanner.new(decode(@scanner.rest))
+        @to_utf = true
+      end
+    end
+  end
+end

data/lib/compat/opal/rexml/text.rb

@@ -0,0 +1,426 @@
+# frozen_string_literal: true
+
+require "rexml/security"
+require "rexml/entity"
+require "rexml/doctype"
+require "rexml/child"
+require "rexml/parseexception"
+
+module REXML
+  # Represents text nodes in an XML document
+  class Text < Child
+    include Comparable
+
+    # The order in which the substitutions occur
+    SPECIALS = [/&(?!#?[\w-]+;)/u, /</u, />/u, /"/u, /'/u, /\r/u].freeze
+    SUBSTITUTES = ["&amp;", "&lt;", "&gt;", "&quot;", "&apos;", "&#13;"].freeze
+    # Characters which are substituted in written strings
+    SLAICEPS = ["<", ">", '"', "'", "&"].freeze
+    SETUTITSBUS = [/&lt;/u, /&gt;/u, /&quot;/u, /&apos;/u, /&amp;/u].freeze
+
+    # If +raw+ is true, then REXML leaves the value alone
+    attr_accessor :raw
+
+    NEEDS_A_SECOND_CHECK = /(<|&((#{Entity::NAME});|(#0*((?:\d+)|(?:x[a-fA-F0-9]+)));)?)/um
+    NUMERICENTITY = /&#0*((?:\d+)|(?:x[a-fA-F0-9]+));/
+    # BMP-only: above-BMP ranges removed for JavaScript regex compatibility.
+    VALID_CHAR = [
+      0x9, 0xA, 0xD,
+      (0x20..0xD7FF),
+      (0xE000..0xFFFD)
+    ].freeze
+
+    VALID_XML_CHARS = Regexp.new("^[" +
+      VALID_CHAR.map { |item|
+        case item
+        when Integer
+          [item].pack("U")
+        when Range
+          [item.first, "-".ord, item.last].pack("UUU")
+        end
+      }.join +
+    "]*$")
+
+    # Constructor
+    # +arg+ if a String, the content is set to the String.  If a Text,
+    # the object is shallowly cloned.
+    #
+    # +respect_whitespace+ (boolean, false) if true, whitespace is
+    # respected
+    #
+    # +parent+ (nil) if this is a Parent object, the parent
+    # will be set to this.
+    #
+    # +raw+ (nil) This argument can be given three values.
+    # If true, then the value of used to construct this object is expected to
+    # contain no unescaped XML markup, and REXML will not change the text. If
+    # this value is false, the string may contain any characters, and REXML will
+    # escape any and all defined entities whose values are contained in the
+    # text.  If this value is nil (the default), then the raw value of the
+    # parent will be used as the raw value for this node.  If there is no raw
+    # value for the parent, and no value is supplied, the default is false.
+    # Use this field if you have entities defined for some text, and you don't
+    # want REXML to escape that text in output.
+    #   Text.new( "<&", false, nil, false ) #-> "&lt;&amp;"
+    #   Text.new( "&lt;&amp;", false, nil, false ) #-> "&amp;lt;&amp;amp;"
+    #   Text.new( "<&", false, nil, true )  #-> Parse exception
+    #   Text.new( "&lt;&amp;", false, nil, true )  #-> "&lt;&amp;"
+    #   # Assume that the entity "s" is defined to be "sean"
+    #   # and that the entity    "r" is defined to be "russell"
+    #   Text.new( "sean russell" )          #-> "&s; &r;"
+    #   Text.new( "sean russell", false, nil, true ) #-> "sean russell"
+    #
+    # +entity_filter+ (nil) This can be an array of entities to match in the
+    # supplied text.  This argument is only useful if +raw+ is set to false.
+    #   Text.new( "sean russell", false, nil, false, ["s"] ) #-> "&s; russell"
+    #   Text.new( "sean russell", false, nil, true, ["s"] ) #-> "sean russell"
+    # In the last example, the +entity_filter+ argument is ignored.
+    #
+    # +illegal+ INTERNAL USE ONLY
+    def initialize(arg, respect_whitespace = false, parent = nil, raw = nil,
+      entity_filter = nil, illegal = NEEDS_A_SECOND_CHECK)
+      @raw = false
+      @parent = nil
+      @entity_filter = nil
+
+      if parent
+        super(parent)
+        @raw = parent.raw
+      end
+
+      if arg.is_a? String
+        @string = arg.dup
+      elsif arg.is_a? Text
+        @string = arg.instance_variable_get(:@string).dup
+        @raw = arg.raw
+        @entity_filter = arg.instance_variable_get(:@entity_filter)
+      else
+        raise "Illegal argument of type #{arg.type} for Text constructor (#{arg})"
+      end
+
+      @string = @string.squeeze(" \n\t") unless respect_whitespace
+      @string = @string.gsub(/\r\n?/, "\n")
+      @raw = raw unless raw.nil?
+      @entity_filter = entity_filter if entity_filter
+      clear_cache
+
+      Text.check(@string, illegal) if @raw
+    end
+
+    def parent=(parent)
+      super
+      Text.check(@string, NEEDS_A_SECOND_CHECK) if @raw && @parent
+    end
+
+    # check for illegal characters
+    def self.check(string, _pattern, _doctype = nil)
+      # illegal anywhere — avoid VALID_XML_CHARS regex on uncontrolled data
+      string.each_char do |c|
+        code = c.ord
+        unless code == 0x9 || code == 0xA || code == 0xD ||
+            code.between?(0x20, 0xD7FF) ||
+            code.between?(0xE000, 0xFFFD)
+          raise "Illegal character #{c.inspect} in raw string #{string.inspect}"
+        end
+      end
+
+      pos = 0
+      while (index = string.index(/<|&/, pos))
+        if string[index] == "<"
+          raise "Illegal character \"#{string[index]}\" in raw string #{string.inspect}"
+        end
+
+        unless (end_index = string.index(/[^\s];/, index + 1))
+          raise "Illegal character \"#{string[index]}\" in raw string #{string.inspect}"
+        end
+
+        value = string[(index + 1)..end_index]
+        if /\s/.match?(value)
+          raise "Illegal character \"#{string[index]}\" in raw string #{string.inspect}"
+        end
+
+        if value[0] == "#"
+          character_reference = value[1..]
+
+          unless /^(\d+|x[0-9a-fA-F]+)$/.match?(character_reference)
+            if character_reference[0] == "x" || character_reference[-1] == "x"
+              raise "Illegal character \"#{string[index]}\" in raw string #{string.inspect}"
+            else
+              raise "Illegal character #{string.inspect} in raw string #{string.inspect}"
+            end
+          end
+
+          case (character_reference[0] == "x" ? character_reference[1..].to_i(16) : character_reference.to_i)
+          when *VALID_CHAR
+          else
+            raise "Illegal character #{string.inspect} in raw string #{string.inspect}"
+          end
+        elsif !/^#{Entity::NAME}$/umo.match?(value)
+          raise "Illegal character \"#{string[index]}\" in raw string #{string.inspect}"
+        end
+
+        pos = end_index + 1
+      end
+
+      string
+    end
+
+    def node_type
+      :text
+    end
+
+    def empty?
+      @string.empty?
+    end
+
+    def clone
+      Text.new(self, true)
+    end
+
+    # Appends text to this text node.  The text is appended in the +raw+ mode
+    # of this text node.
+    #
+    # +returns+ the text itself to enable method chain like
+    # 'text << "XXX" << "YYY"'.
+    def <<(to_append)
+      @string << to_append.gsub(/\r\n?/, "\n")
+      clear_cache
+      self
+    end
+
+    # +other+ a String or a Text
+    # +returns+ the result of (to_s <=> arg.to_s)
+    def <=>(other)
+      to_s <=> other.to_s
+    end
+
+    def doctype
+      @parent&.document&.doctype
+    end
+
+    REFERENCE = /#{Entity::REFERENCE}/
+    # Returns the string value of this text node.  This string is always
+    # escaped, meaning that it is a valid XML text node string, and all
+    # entities that can be escaped, have been inserted.  This method respects
+    # the entity filter set in the constructor.
+    #
+    #   # Assume that the entity "s" is defined to be "sean", and that the
+    #   # entity "r" is defined to be "russell"
+    #   t = Text.new( "< & sean russell", false, nil, false, ['s'] )
+    #   t.to_s   #-> "&lt; &amp; &s; russell"
+    #   t = Text.new( "< & &s; russell", false, nil, false )
+    #   t.to_s   #-> "&lt; &amp; &s; russell"
+    #   u = Text.new( "sean russell", false, nil, true )
+    #   u.to_s   #-> "sean russell"
+    def to_s
+      return @string if @raw
+
+      @to_s ||= Text::normalize(@string, doctype, @entity_filter)
+    end
+
+    def inspect
+      @string.inspect
+    end
+
+    # Returns the string value of this text.  This is the text without
+    # entities, as it might be used programmatically, or printed to the
+    # console.  This ignores the 'raw' attribute setting, and any
+    # entity_filter.
+    #
+    #   # Assume that the entity "s" is defined to be "sean", and that the
+    #   # entity "r" is defined to be "russell"
+    #   t = Text.new( "< & sean russell", false, nil, false, ['s'] )
+    #   t.value   #-> "< & sean russell"
+    #   t = Text.new( "< & &s; russell", false, nil, false )
+    #   t.value   #-> "< & sean russell"
+    #   u = Text.new( "sean russell", false, nil, true )
+    #   u.value   #-> "sean russell"
+    def value
+      @value ||= Text::unnormalize(@string, doctype,
+                                   entity_expansion_text_limit: document&.entity_expansion_text_limit)
+    end
+
+    # Sets the contents of this text node.  This expects the text to be
+    # unnormalized.  It returns self.
+    #
+    #   e = Element.new( "a" )
+    #   e.add_text( "foo" )   # <a>foo</a>
+    #   e[0].value = "bar"    # <a>bar</a>
+    #   e[0].value = "<a>"    # <a>&lt;a&gt;</a>
+    def value=(val)
+      @string = val.gsub(/\r\n?/, "\n")
+      clear_cache
+      @raw = false
+    end
+
+    def wrap(string, width, addnewline = false)
+      # Recursively wrap string at width.
+      return string if string.length <= width
+
+      place = string.rindex(" ", width) # Position in string with last ' ' before cutoff
+      if addnewline
+        "\n#{string[0, place]}\n#{wrap(string[(place + 1)..], width)}"
+      else
+        "#{string[0, place]}\n#{wrap(string[(place + 1)..], width)}"
+      end
+    end
+
+    def indent_text(string, level = 1, style = "\t", indentfirstline = true)
+      Kernel.warn(
+        "#{self.class.name}#indent_text is deprecated. See REXML::Formatters", uplevel: 1
+      )
+      return string if level.negative?
+
+      new_string = +""
+      string.each_line do |line|
+        indent_string = style * level
+        new_line = (indent_string + line).rstrip
+        new_string << new_line
+      end
+      new_string.strip! unless indentfirstline
+      new_string
+    end
+
+    # == DEPRECATED
+    # See REXML::Formatters
+    #
+    def write(writer, indent = -1, _transitive = false, _ie_hack = false)
+      Kernel.warn(
+        "#{self.class.name}#write is deprecated.  See REXML::Formatters", uplevel: 1
+      )
+      formatter = if indent > -1
+                    REXML::Formatters::Pretty.new(indent)
+                  else
+                    REXML::Formatters::Default.new
+                  end
+      formatter.write(self, writer)
+    end
+
+    # FIXME
+    # This probably won't work properly
+    def xpath
+      "#{@parent.xpath}/text()"
+    end
+
+    # Writes out text, substituting special characters beforehand.
+    # +out+ A String, IO, or any other object supporting <<( String )
+    # +input+ the text to substitute and the write out
+    #
+    #   z=utf8.unpack("U*")
+    #   ascOut=""
+    #   z.each{|r|
+    #     if r <  0x100
+    #       ascOut.concat(r.chr)
+    #     else
+    #       ascOut.concat(sprintf("&#x%x;", r))
+    #     end
+    #   }
+    #   puts ascOut
+    def write_with_substitution(out, input)
+      copy = input.clone
+      # Doing it like this rather than in a loop improves the speed
+      copy.gsub!(SPECIALS[0], SUBSTITUTES[0])
+      copy.gsub!(SPECIALS[1], SUBSTITUTES[1])
+      copy.gsub!(SPECIALS[2], SUBSTITUTES[2])
+      copy.gsub!(SPECIALS[3], SUBSTITUTES[3])
+      copy.gsub!(SPECIALS[4], SUBSTITUTES[4])
+      copy.gsub!(SPECIALS[5], SUBSTITUTES[5])
+      out << copy
+    end
+
+    private
+
+    def clear_cache
+      @normalized = nil
+      @unnormalized = nil
+    end
+
+    # Reads text, substituting entities
+    def self.read_with_substitution(input, illegal = nil)
+      copy = input.clone
+
+      if illegal && illegal && (copy =~ illegal)
+        raise ParseException.new("malformed text: Illegal character #$& in \"#{copy}\"")
+      end
+
+      copy.gsub!(/\r\n?/, "\n")
+      if copy.include? ?&
+        copy.gsub!(SETUTITSBUS[0], SLAICEPS[0])
+        copy.gsub!(SETUTITSBUS[1], SLAICEPS[1])
+        copy.gsub!(SETUTITSBUS[2], SLAICEPS[2])
+        copy.gsub!(SETUTITSBUS[3], SLAICEPS[3])
+        copy.gsub!(SETUTITSBUS[4], SLAICEPS[4])
+        copy.gsub!(/&#0*((?:\d+)|(?:x[a-f0-9]+));/) do
+          m = $1
+          # m='0' if m==''
+          m = "0#{m}" if m[0] == ?x
+          [Integer(m)].pack("U*")
+        end
+      end
+      copy
+    end
+
+    EREFERENCE = /&(?!#{Entity::NAME};)/
+    # Escapes all possible entities
+    def self.normalize(input, doctype = nil, entity_filter = nil)
+      copy = input.to_s
+      # Doing it like this rather than in a loop improves the speed
+      # copy = copy.gsub( EREFERENCE, '&amp;' )
+      copy = copy.gsub("&", "&amp;") if copy.include?("&")
+      if doctype
+        # Replace all ampersands that aren't part of an entity
+        doctype.entities.each_value do |entity|
+          if entity.value &&
+              not(entity_filter && entity_filter.include?(entity.name))
+            copy = copy.gsub(entity.value,
+                             "&#{entity.name};")
+          end
+        end
+      else
+        # Replace all ampersands that aren't part of an entity
+        DocType::DEFAULT_ENTITIES.each_value do |entity|
+          if copy.include?(entity.value)
+            copy = copy.gsub(entity.value, "&#{entity.name};")
+          end
+        end
+      end
+      copy
+    end
+
+    # Unescapes all possible entities
+    def self.unnormalize(string, doctype = nil, filter = nil, _illegal = nil,
+entity_expansion_text_limit: nil)
+      entity_expansion_text_limit ||= Security.entity_expansion_text_limit
+      sum = 0
+      string.gsub(/\r\n?/, "\n").gsub(REFERENCE) do
+        s = Text.expand($&, doctype, filter)
+        if sum + s.bytesize > entity_expansion_text_limit
+          raise "entity expansion has grown too large"
+        else
+          sum += s.bytesize
+        end
+
+        s
+      end
+    end
+
+    def self.expand(ref, doctype, filter)
+      if ref[1] == ?#
+        if ref[2] == ?x
+          [ref[3...-1].to_i(16)].pack("U*")
+        else
+          [ref[2...-1].to_i].pack("U*")
+        end
+      elsif ref == "&amp;"
+        "&"
+      elsif filter&.include?(ref[1...-1])
+        ref
+      elsif doctype
+        doctype.entity(ref[1...-1]) or ref
+      else
+        entity_value = DocType::DEFAULT_ENTITIES[ref[1...-1]]
+        entity_value ? entity_value.value : ref
+      end
+    end
+  end
+end

data/lib/compat/opal/rexml/xmltokens.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: false
+
+module REXML
+  module XMLTokens
+    name_start_chars = [
+      ":",
+      "A-Z",
+      "_",
+      "a-z",
+      "\\u00C0-\\u00D6",
+      "\\u00D8-\\u00F6",
+      "\\u00F8-\\u02FF",
+      "\\u0370-\\u037D",
+      "\\u037F-\\u1FFF",
+      "\\u200C-\\u200D",
+      "\\u2070-\\u218F",
+      "\\u2C00-\\u2FEF",
+      "\\u3001-\\uD7FF",
+      "\\uF900-\\uFDCF",
+      "\\uFDF0-\\uFFFD",
+    ]
+
+    name_chars = name_start_chars + [
+      "\\-",
+      "\\.",
+      "0-9",
+      "\\u00B7",
+      "\\u0300-\\u036F",
+      "\\u203F-\\u2040",
+    ]
+    NAME_START_CHAR = "[#{name_start_chars.join}]".freeze
+    NAME_CHAR = "[#{name_chars.join}]".freeze
+    NAMECHAR = NAME_CHAR
+
+    ncname_start_chars = name_start_chars - [":"]
+    ncname_chars = name_chars - [":"]
+    NCNAME_STR = "[#{ncname_start_chars.join}][#{ncname_chars.join}]*".freeze
+    NAME_STR = "(?:#{NCNAME_STR}:)?#{NCNAME_STR}".freeze
+
+    NAME = "(#{NAME_START_CHAR}#{NAME_CHAR}*)".freeze
+    NMTOKEN = "(?:#{NAME_CHAR})+".freeze
+    NMTOKENS = "#{NMTOKEN}(\\s+#{NMTOKEN})*".freeze
+    REFERENCE = "(?:&#{NAME};|&#\\d+;|&#x[0-9a-fA-F]+;)".freeze
+  end
+end