yeptris 0.6.18.2-arm-linux-eabihf

data/lib/yeptris/psych/parser.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Yeptris
+  module Psych
+    # The event parser (TODO.impl/15 phase E): drives a Handler with
+    # Psych's exact event shapes over the yeptris recorder — one bulk
+    # record drain (the Materializer's seam), then a pure-Ruby
+    # dispatch loop. No callback marshaling, no per-event FFI calls.
+    class Parser
+      attr_accessor :handler
+      attr_reader :filename
+
+      ANY = 0
+      UTF8 = 1
+      UTF16LE = 2
+      UTF16BE = 3
+
+      def initialize(handler = Handler.new)
+        @handler = handler
+        @filename = nil
+      end
+
+      def parse(yaml, filename = nil)
+        yaml = Yeptris.read_input(yaml)
+        yaml = yaml.to_s
+        @filename = filename
+        flat, arena = Materializer.drain(yaml, schema: :compat_11)
+        dispatch(flat, arena)
+        self
+      rescue ParseError => e
+        raise SyntaxError.from_parse_error(e)
+      end
+
+      private
+
+      STREAM_START = Materializer::STREAM_START
+      STREAM_END = Materializer::STREAM_END
+      DOCUMENT_START = Materializer::DOCUMENT_START
+      DOCUMENT_END = Materializer::DOCUMENT_END
+      SEQUENCE_START = Materializer::SEQUENCE_START
+      MAPPING_START = Materializer::MAPPING_START
+      SCALAR = Materializer::SCALAR
+      ALIAS = Materializer::ALIAS
+
+      EF_FLOW = 1 << 0
+      EF_EXPLICIT = 1 << 1
+      STYLE_PLAIN = 1
+      STYLE_SINGLE_QUOTED = 2
+      STYLE_DOUBLE_QUOTED = 3
+
+      def dispatch(flat, arena)
+        h = @handler
+        i = 0
+        while i < flat.length
+          type = flat[i]
+          style = flat[i + 1]
+          flags = flat[i + 2]
+          value = field(flat, arena, i + 6)
+          anchor = field(flat, arena, i + 8)
+          tag = field(flat, arena, i + 10)
+          case type
+          when STREAM_START then h.start_stream(UTF8)
+          when STREAM_END then h.end_stream
+          # version: [] when no %YAML directive (Psych's own shape);
+          # a declared directive's [major, minor] is not carried by
+          # the record — the one documented divergence
+          when DOCUMENT_START then h.start_document([], [], (flags & EF_EXPLICIT).zero?)
+          when DOCUMENT_END then h.end_document((flags & EF_EXPLICIT).zero?)
+          when SEQUENCE_START
+            h.start_sequence(anchor, tag, tag.nil?, (flags & EF_FLOW).zero? ? Handler::BLOCK : Handler::FLOW)
+          when Materializer::SEQUENCE_END then h.end_sequence
+          when MAPPING_START
+            h.start_mapping(anchor, tag, tag.nil?, (flags & EF_FLOW).zero? ? Handler::BLOCK : Handler::FLOW)
+          when Materializer::MAPPING_END then h.end_mapping
+          when SCALAR
+            # A synthesized empty scalar (empty document, '?' empty
+            # key) carries style ANY(0); Psych's C emits plain(1)
+            # with an empty String value — normalized here, at the
+            # boundary, so the emitter's style chooser is untouched
+            if style.zero?
+              style = STYLE_PLAIN
+            end
+            value = +"" if value.nil?
+            # libyaml's plain_implicit: a plain scalar that carried
+            # no explicit tag (an explicit tag kills implicit typing)
+            plain = style == STYLE_PLAIN && tag.nil?
+            # quoted_implicit covers every explicit style — single,
+            # double, literal, folded — when the tag was absent
+            quoted = !plain && tag.nil? && style > STYLE_PLAIN
+            h.scalar(value, anchor, tag, plain, quoted, style)
+          when ALIAS then h.alias(value)
+          end
+          i += Materializer::FIELDS
+        end
+      end
+
+      def field(flat, arena, at)
+        len = flat[at + 1]
+        return nil if len.zero?
+
+        arena.byteslice(flat[at], len)
+      end
+    end
+  end
+end

data/lib/yeptris/psych/scalar_scanner.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require "date"
+
+module Yeptris
+  module Psych
+    ###
+    # Scan scalars for built in types — the stdlib Psych::ScalarScanner
+    # port (#179): same regexes, same precedence, same edge verdicts.
+    # The load path types through the C resolver; this class is the
+    # standalone API stdlib code (and Psych's own tests) drive directly.
+    class ScalarScanner
+      # Taken from http://yaml.org/type/timestamp.html
+      TIME = /^-?\d{4}-\d{1,2}-\d{1,2}(?:[Tt]|\s+)\d{1,2}:\d\d:\d\d(?:\.\d*)?(?:\s*(?:Z|[-+]\d{1,2}:?(?:\d\d)?))?$/
+
+      # Taken from http://yaml.org/type/float.html
+      # Base 60, [-+]inf and NaN are handled separately
+      FLOAT = /^(?:[-+]?([0-9][0-9_,]*)?\.[0-9]*([eE][-+][0-9]+)?(?# base 10))$/x
+
+      # Taken from http://yaml.org/type/int.html and modified to ensure at least one numerical symbol exists
+      INTEGER_STRICT = /^(?:[-+]?0b[_]*[0-1][0-1_]*             (?# base 2)
+                           |[-+]?0[_]*[0-7][0-7_]*              (?# base 8)
+                           |[-+]?(0|[1-9][0-9_]*)               (?# base 10)
+                           |[-+]?0x[_]*[0-9a-fA-F][0-9a-fA-F_]* (?# base 16))$/x
+
+      # Same as above, but allows commas.
+      # Not to YML spec, but kept for backwards compatibility
+      INTEGER_LEGACY = /^(?:[-+]?0b[_,]*[0-1][0-1_,]*                (?# base 2)
+                           |[-+]?0[_,]*[0-7][0-7_,]*                 (?# base 8)
+                           |[-+]?(?:0|[1-9](?:[0-9]|,[0-9]|_[0-9])*) (?# base 10)
+                           |[-+]?0x[_,]*[0-9a-fA-F][0-9a-fA-F_,]*    (?# base 16))$/x
+
+      BOOLEAN_TRUE  = /^(yes|true|on)$/i
+      BOOLEAN_FALSE = /^(no|false|off)$/i
+
+      attr_reader :class_loader
+
+      # Create a new scanner
+      def initialize class_loader = ClassLoader, strict_integer: false, parse_symbols: true
+        @symbol_cache = {}
+        @class_loader = class_loader
+        @strict_integer = strict_integer
+        @parse_symbols = parse_symbols
+      end
+
+      # Tokenize +string+ returning the Ruby object
+      def tokenize string
+        return nil if string.empty?
+        return @symbol_cache[string] if @symbol_cache.key?(string)
+        integer_regex = @strict_integer ? INTEGER_STRICT : INTEGER_LEGACY
+        # Check for a String type, being careful not to get caught by hash keys, hex values, and
+        # special floats (e.g., -.inf).
+        if string.match?(%r{^[^\d.:-]?[[:alpha:]_\s!@#$%\^&*(){}<>|/\\~;=]+}) || string.match?(/\n/)
+          return string if string.length > 5
+
+          if string.match?(/^[^ytonf~]/i)
+            string
+          elsif string == '~' || string.match?(/^null$/i)
+            nil
+          elsif string.match?(BOOLEAN_TRUE)
+            true
+          elsif string.match?(BOOLEAN_FALSE)
+            false
+          else
+            string
+          end
+        elsif string.match?(TIME)
+          begin
+            parse_time string
+          rescue ArgumentError
+            string
+          end
+        elsif string.match?(/^\d{4}-(?:1[012]|0\d|\d)-(?:[12]\d|3[01]|0\d|\d)$/)
+          begin
+            class_loader.date.strptime(string, '%F', Date::GREGORIAN)
+          rescue ArgumentError
+            string
+          end
+        elsif string.match?(/^\+?\.inf$/i)
+          Float::INFINITY
+        elsif string.match?(/^-\.inf$/i)
+          -Float::INFINITY
+        elsif string.match?(/^\.nan$/i)
+          Float::NAN
+        elsif @parse_symbols && string.match?(/^:./)
+          if string =~ /^:(["'])(.*)\1/
+            @symbol_cache[string] = class_loader.symbolize($2.sub(/^:/, ''))
+          else
+            @symbol_cache[string] = class_loader.symbolize(string.sub(/^:/, ''))
+          end
+        elsif string.match?(/^[-+]?[0-9][0-9_]*(:[0-5]?[0-9]){1,2}$/)
+          i = 0
+          string.split(':').each_with_index do |n, e|
+            i += (n.to_i * 60**(e - 2).abs)
+          end
+          i
+        elsif string.match?(/^[-+]?[0-9][0-9_]*(:[0-5]?[0-9]){1,2}\.[0-9_]*$/)
+          i = 0
+          string.split(':').each_with_index do |n, e|
+            i += (n.to_f * 60**(e - 2).abs)
+          end
+          i
+        elsif string.match?(FLOAT)
+          if string.match?(/\A[-+]?\.\Z/)
+            string
+          else
+            Float(string.delete(',_').gsub(/\.([Ee]|$)/, '\1'))
+          end
+        elsif string.match?(integer_regex)
+          parse_int string
+        else
+          string
+        end
+      end
+
+      # Parse and return an int from +string+
+      def parse_int string
+        Integer(string.delete(',_'))
+      end
+
+      ###
+      # Parse and return a Time from +string+
+      def parse_time string
+        date, time = *(string.split(/[Tt]|\s+/, 2))
+        (yy, m, dd) = date.match(/^(-?\d{4})-(\d{1,2})-(\d{1,2})/).captures.map { |x| x.to_i }
+        md = time.match(/(\d+:\d+:\d+)(?:\.(\d*))?\s*(Z|[-+]\d+(:\d\d)?)?/)
+
+        (hh, mm, ss) = md[1].split(':').map { |x| x.to_i }
+        us = (md[2] ? Rational("0.#{md[2]}") : 0) * 1_000_000
+
+        time = Time.utc(yy, m, dd, hh, mm, ss, us)
+
+        return time if 'Z' == md[3]
+        return Time.at(time.to_i, us) unless md[3]
+
+        tz = md[3].match(/^([+\-]?\d{1,2})\:?(\d{1,2})?$/)[1..-1].compact.map { |digit| Integer(digit, 10) }
+        offset = tz.first * 3600
+
+        if offset < 0
+          offset -= ((tz[1] || 0) * 60)
+        else
+          offset += ((tz[1] || 0) * 60)
+        end
+
+        Time.new(yy, m, dd, hh, mm, ss + us / 1_000_000r, offset)
+      end
+    end
+  end
+end