yeptris 0.6.56.1-arm-linux-eabihf → 0.6.58.1-arm-linux-eabihf

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 92277802904cb56365eae27dfc3929fcbeceec3db850dbc95138127b3990f715
-  data.tar.gz: cf8b22137e0eea5536a25bbc9fa702ead3a939fea02681256632ee2041fd173f
+  metadata.gz: 23d3c8dc0b4600de5a60826f71cf3ffb2d7517c8a6e0c8f588aee724320782e3
+  data.tar.gz: '067915418bf97cccf16cc015e4b78959d45270ff97c8d0372b988b9b3bab1b7c'
 SHA512:
-  metadata.gz: 5805c0315c67b0b3db2fc87575d39dc61a7c5f906a265bd580c22b6ec74bb349e9a7df8efbfaf8ff70f88505c6b58777ec6bf5598ece063c94b9cf3e5f5d4edd
-  data.tar.gz: 467fc637747e2249e18ee22dda61a58ed475ebaede6f4196c6f9f4e3b905105f0813e4ad55e481ee280ba767c6f28e067bc859e896e2b5bc4938df8f587c3a87
+  metadata.gz: 47511ed558cbf416de324e79679163e1dabcaecdbe009317c240015c6d063ddb3d212b215af60f8181d0e08c1d863f94ff4b5531362edc95c07f80bb1059f7d0
+  data.tar.gz: afc2c53b583f6637902bdeb8e8d506309be3beb412af4d7f664a462332360ec50cb9340bea3909601776ab72a5b6e8aeebfd1ffe1bb22568cc13ccb145e0be96

data/ext/yeptris_native/version.h

@@ -11,8 +11,8 @@
 
 #define YEPTRIS_VERSION_MAJOR 0
 #define YEPTRIS_VERSION_MINOR 6
-#define YEPTRIS_VERSION_PATCH 56
-#define YEPTRIS_VERSION_STRING "0.6.56"
+#define YEPTRIS_VERSION_PATCH 58
+#define YEPTRIS_VERSION_STRING "0.6.58"
 
 #ifdef __cplusplus
 extern "C" {

data/lib/yeptris/psych/visitors.rb

@@ -437,6 +437,10 @@ module Yeptris
           when /\A!ruby\/object(?::(.+))?\z/
             klass = resolve_class(Regexp.last_match(1).to_s)
             revive_object(klass, node)
+          when /\A!ruby\/hash:(.+)\z/
+            revive_hash_class(resolve_class(Regexp.last_match(1)), node)
+          when /\A!ruby\/exception(?::(.*))?\z/
+            revive_exception(resolve_class(Regexp.last_match(1).to_s), node)
           else
             # Psych.load_tags first (the class registry, #95 bug 4);
             # anything else stays the plain mapping
@@ -452,9 +456,13 @@ module Yeptris
         # key's SHAPE decides (an explicit !!str '<<' is a literal key,
         # not a merge), the VALUE's node kind picks the arm, and every
         # merge is TypeError-guarded (a bad element keeps the whole
-        # '<<' pair literal — merges are all-or-nothing).
-        def hash_into(h, node)
-          anchors[node.anchor] = h if node.anchor
+        # '<<' pair literal — merges are all-or-nothing). The anchor
+        # registrant is the receiver by default; the object revivals
+        # pass the revived OBJ (psych's revive(): the object itself is
+        # registered before the children walk, so an alias inside an
+        # ivar pointing back at the object resolves to it).
+        def hash_into(h, node, anchor: nil)
+          anchors[node.anchor] = (anchor || h) if node.anchor
           node.children.each_slice(2) do |k, v|
             key = visit(k)
             val = visit(v)
@@ -502,29 +510,124 @@ module Yeptris
         end
 
         def revive_object(klass, node)
-          # bare !ruby/object (no class): Psych.dump(Object.new)'s form.
-          # An Object has no declared state — allocation is the whole
-          # revival (no reflection, no protocol needed).
-          return ::Object.allocate if klass.nil?
+          obj = klass ? klass.allocate : ::Object.allocate
+          # psych's revive(): the object registers BEFORE the children
+          # walk — an alias inside the state pointing back at the
+          # object resolves to it (identity through ivars)
+          anchors[node.anchor] = obj if node.anchor
 
-          raise ::Yeptris::DumpError, "#{klass} is not Yeptris::Psych::Encodable: implement init_with(coder)" unless klass <= ::Yeptris::Psych::Encodable
+          if klass
+            # The yeptris encoder's format (visit_encode_with): the
+            # Encodable protocol rides the __init__ marker, so the
+            # state passes back through init_with(coder) without
+            # library-side ivar reflection. The format decides on the
+            # RAW key before any value is visited (the old walk's
+            # shape; sibling values stay untouched when it fires).
+            init = nil
+            node.children.each_slice(2) do |k, v|
+              init = v if k.to_ruby.to_s == "__init__"
+            end
+            if init
+              unless klass <= ::Yeptris::Psych::Encodable
+                raise ::Yeptris::DumpError,
+                      "#{klass} is not Yeptris::Psych::Encodable: implement init_with(coder)"
+              end
 
-          obj = klass.allocate
-          anchors[node.anchor] = obj if node.anchor
-          # The class opts in via init_with(coder); the encoder wrote
-          # `coder["__init__"] = the mapping` so we can pass it back
-          # without library-side ivar reflection.
+              coder = ::Yeptris::Psych::CoderShim.new
+              if init.is_a?(::Yeptris::Psych::Nodes::Mapping)
+                init.children.each_slice(2) do |ck, cv|
+                  coder[ck.to_ruby.to_s] = visit(cv)
+                end
+              end
+              obj.init_with(coder)
+              return obj
+            end
+          end
+
+          # stdlib psych's format (visit_Object + dump_ivars): the
+          # mapping's own top-level pairs ARE the object state —
+          # revives through init_with when the class defines it, ivar
+          # assignment otherwise. THE AUDIT FIX: the __init__-only
+          # walk silently dropped the ivars of every stdlib
+          # Psych.dump-produced document.
+          init_with_state(obj, hash_into({}, node, anchor: obj), node)
+          obj
+        end
+
+        # !ruby/hash:K (stdlib visit_Hash of a Hash subclass): the
+        # SUBCLASS allocates and the mapping's own pairs fill it
+        # (merge keys included, hash_into semantics). A name that
+        # resolves to a non-Hash raises stdlib resolve_subclass's
+        # ArgumentError; an unresolvable name stays a plain Hash (the
+        # resolve_class-returns-nil convention this binding already
+        # applies to !ruby/object and !ruby/struct — safe_load raises
+        # DisallowedClass for it first).
+        def revive_hash_class(klass, node)
+          if klass
+            unless klass <= ::Hash
+              raise ::ArgumentError, "Invalid tag: expected a subclass of Hash, got #{klass}"
+            end
+
+            h = klass.allocate
+          else
+            h = {}
+          end
+          anchors[node.anchor] = h if node.anchor
+          hash_into(h, node)
+          h
+        end
+
+        # !ruby/exception[:K] (stdlib visit_Exception + build_exception):
+        # the message rides the exception's own construction surface
+        # (Class#exception — psych's C build_exception writes the
+        # engine-internal mesg slot on an allocated instance, which
+        # Ruby-level ivar assignment cannot reach: message would stay
+        # the class name), backtrace is consumed if present, and every
+        # other pair lands as ivars (message/backtrace excepted — they
+        # name the exception's own surface, not object state). Bare
+        # !ruby/exception rides ::Exception (psych's class_loader
+        # exception fallback). A subclass whose initialize refuses a
+        # message argument constructs bare — same fallback psych's
+        # Ruby-side build_exception carried before the C move.
+        def revive_exception(klass, node)
+          h = {}
           node.children.each_slice(2) do |k, v|
-            key = k.to_ruby.to_s
-            next unless key == "__init__"
+            h[visit(k)] = visit(v)
+          end
+          mesg = h.delete("message")
+          e = build_exception(klass || ::Exception, mesg)
+          anchors[node.anchor] = e if node.anchor
+          e.set_backtrace(h.delete("backtrace")) if h.key?("backtrace")
+          init_with_state(e, h, node)
+          e
+        end
 
+        def build_exception(klass, mesg)
+          return klass.exception if mesg.nil?
+
+          begin
+            klass.exception(mesg)
+          rescue ::ArgumentError, ::TypeError
+            klass.exception
+          end
+        end
+
+        # psych's init_with: a class defining init_with takes the coder
+        # (the raw pair map, coder.tag = the mapping's tag); everything
+        # else — bare Object included — takes the pairs as ivars. Keys
+        # are @-normalized both ways: stdlib DUMPS the ivars @-stripped
+        # (yaml_tree's dump_ivars), older psych and hand-written docs
+        # spell them WITH the @ — both map to the same ivar.
+        def init_with_state(obj, h, node)
+          if obj.respond_to?(:init_with)
             coder = ::Yeptris::Psych::CoderShim.new
-            if v.is_a?(::Yeptris::Psych::Nodes::Mapping)
-              v.children.each_slice(2) do |ck, cv|
-                coder[ck.to_ruby.to_s] = visit(cv)
-              end
-            end
+            coder.tag = node.tag
+            h.each { |k, v| coder[k] = v }
             obj.init_with(coder)
+          else
+            h.each do |k, v|
+              obj.instance_variable_set(:"@#{k.to_s.sub(/\A@/, "")}", v)
+            end
           end
           obj
         end

data/lib/yeptris/psych.rb

@@ -208,11 +208,14 @@ module Yeptris
 
       def safe_load(yaml, permitted_classes: [::Date, ::Time], aliases: false,
                     symbolize_names: false, **)
+        # ONE read at the boundary (read_input): IO-like input must be
+        # consumed once — the string rides parse AND the slice below
+        source = ::Yeptris.read_input(yaml)
         begin
-          doc = Yeptris::Document.parse(yaml, schema: :compat_11)
+          doc = Yeptris::Document.parse(source, schema: :compat_11)
           return nil if doc.nil? # the legal empty stream
 
-          res = force_utf8_scalars(walk_safe(doc.root(0), permitted_classes, aliases))
+          res = force_utf8_scalars(walk_safe(doc.root(0), permitted_classes, aliases, source))
           res = deep_symbolize_keys(res) if symbolize_names
           res
         rescue ::Yeptris::ParseError => e
@@ -290,23 +293,78 @@ module Yeptris
         ::Yeptris::Psych.dump(obj, io, options)
       end
 
-      def load_stream(yaml, **kwargs, &block)
-        # materialize each document's root directly — the stream
-        # children share one C document, so their handles would all
-        # resolve to the first document's tree. stdlib's block form
-        # yields each loaded document's object (#179 round 4).
-        doc = Yeptris::Document.parse(yaml, schema: :compat_11)
-        return nil if doc.nil? # the legal empty stream
-
-        begin
-          docs = (0...doc.document_count).map { |i| doc.root(i).to_ruby }
-        ensure
-          doc.free
+      # stdlib's load_stream (yeptris#881): every document of the
+      # stream, in order — the block form yields each loaded document.
+      # The engine's stream parse drives the boundaries (--- / ... /
+      # implicit documents after a ...); empty documents are nil
+      # elements, exactly what stdlib yields.
+      #
+      # errors: :raise (default) re-raises a bad document as stdlib's
+      # family — Psych::SyntaxError (parse() translates the same way).
+      # errors: :collect never raises for a bad document: the stream
+      # re-walks at marker boundaries (Yeptris::YAML._stream_slices)
+      # through this face's own DOM materialization, and the bad
+      # document's position carries the SyntaxError marker.
+      def load_stream(yaml, errors: :raise, **kwargs, &block)
+        unless %i[raise collect].include?(errors)
+          raise ArgumentError, "errors: must be :raise or :collect (got #{errors.inspect})"
         end
+
+        # once, up front: the collect fallback re-parses this text and
+        # an IO input would already be at EOF by then
+        yaml = ::Yeptris.read_input(yaml).to_s
+        docs =
+          begin
+            # materialize each document's root directly — the stream
+            # children share one C document, so their handles would all
+            # resolve to the first document's tree. stdlib's block form
+            # yields each loaded document's object (#179 round 4).
+            doc = ::Yeptris::Document.parse(yaml, schema: :compat_11)
+            if doc.nil?
+              # the legal empty stream: stdlib answers a stream object
+              # with no children; the array face answers []
+              []
+            else
+              begin
+                (0...doc.document_count).map { |i| doc.root(i).to_ruby }
+              ensure
+                doc.free
+              end
+            end
+          rescue ::Yeptris::ParseError => e
+            # stdlib's family for a bad document (parse() translates
+            # the same way); in collect mode the bad document's
+            # position carries the SyntaxError marker instead
+            raise SyntaxError.from_parse_error(e) if errors != :collect
+
+            _collect_stream(yaml)
+          end
         docs.each { |d| block.call(d) } if block
         docs
       end
 
+      # The errors: :collect fallback: parse the marker-boundary
+      # slices through this face's own DOM materialization; a failed
+      # slice's position carries the SyntaxError marker.
+      def _collect_stream(yaml)
+        results = []
+        ::Yeptris::YAML._stream_slices(yaml).each do |slice|
+          begin
+            doc = ::Yeptris::Document.parse(slice, schema: :compat_11)
+            next if doc.nil?
+
+            begin
+              (0...doc.document_count).each { |i| results << doc.root(i).to_ruby }
+            ensure
+              doc.free
+            end
+          rescue ::Yeptris::ParseError => e
+            results << SyntaxError.from_parse_error(e)
+          end
+        end
+        results
+      end
+
       # safe_load_stream: stdlib's surface — the stream form of
       # safe_load. Our load_stream is already safe-by-default
       # (Psych 5 semantics), so this is the yielding wrapper.
@@ -406,7 +464,25 @@ module Yeptris
       # class outside the permitted set raises too (issue #69: a
       # compat_11 date must not become a Date unless Date is
       # permitted — Psych::DisallowedClass semantics).
-      def walk_safe(root, permitted, aliases_enabled)
+      #
+      # The single-pass slice (#862): the gate walk IS the cost —
+      # per-node FFI reads. Three provable facts retire it for clean
+      # documents: the parser cannot build an alias without a `*`
+      # byte in the source, cannot build an explicit tag without a
+      # `!` byte, and the marshal builder REFUSES timestamps and
+      # merge keys (its success proves none exist — every
+      # timestamp-typed shape is refused, verified per shape). So
+      # `marshal_fast` doubles as the probe AND the build in one C
+      # call: on a gate-free source its success proves check() could
+      # not have raised, and the walk disappears; a refusal or a gate
+      # byte falls back to the checked walk, which is byte-for-byte
+      # the old path.
+      def walk_safe(root, permitted, aliases_enabled, source = nil)
+        if root && !source.nil? &&
+           !source.include?("*") && !source.include?("!")
+          fast = root.marshal_fast
+          return fast unless fast.nil?
+        end
         check(root, permitted, aliases_enabled) if root
         root.to_ruby
       end

data/lib/yeptris/yaml.rb

@@ -44,11 +44,100 @@ module Yeptris
       Psych.safe_load(yaml.to_s, permitted_classes: permitted_classes, aliases: aliases)
     end
 
-    # Every document in the stream, in order.
-    def load_stream(yaml, schema: :compat_11)
+    # Every document in the stream, in order (the multi-document stream
+    # API, yeptris#881 — Psych's load_stream parity). Document boundary
+    # detection follows the engine's stream parse: explicit --- / ...
+    # markers, implicit documents after a ... terminator, and empty
+    # documents — nil elements, exactly what Psych yields for them.
+    #
+    # errors: :raise (default) raises Yeptris::ParseError on the first
+    # bad document — psych's behavior (a stream parse cannot resume
+    # past it). errors: :collect never raises for a bad document: the
+    # text re-walks at marker boundaries (see _stream_slices) and the
+    # bad document's position carries a Yeptris::ParseError marker
+    # (skip with results.grep(Yeptris::ParseError)). A stream that
+    # parses whole collects to the same plain document array as :raise.
+    #
+    # With a block, every element — documents and, under :collect,
+    # error markers — is yielded in order; the array is returned.
+    def load_stream(yaml, schema: :compat_11, errors: :raise, &block)
+      unless %i[raise collect].include?(errors)
+        raise ArgumentError, "errors: must be :raise or :collect (got #{errors.inspect})"
+      end
+
       yaml = Yeptris.read_input(yaml)
       yaml = yaml.to_s
-      _drain_all(yaml, schema)
+      docs =
+        begin
+          docs = _drain_all(yaml, schema)
+          # The value drain emits a nil record even for a stream with
+          # ZERO documents ("", a blank line, a comment) — stdlib's
+          # load_stream answers zero documents there, and the corner
+          # must not mask a real empty document ("---\n" IS [nil]).
+          # Only the [nil] shape needs the discriminating DOM count,
+          # so the good path pays nothing.
+          if docs == [nil]
+            doc = Document.parse(yaml, schema: schema)
+            docs = [] if doc.nil? || doc.document_count.zero?
+            doc&.free
+          end
+          docs
+        rescue ParseError
+          raise if errors != :collect
+
+          _collect_stream(yaml, schema)
+        end
+      docs.each { |d| block.call(d) } if block
+      docs
+    end
+
+    # A column-0 --- / ... marker line. A real document boundary in
+    # every valid YAML stream (block/scalar content can never carry one
+    # unindented), so the scan is exact — it never splits inside a
+    # document. Marker-less boundaries (implicit documents after a
+    # ...) stay INSIDE their slice, and each slice parses through the
+    # full stream face, so nothing is lost there either. Slices keep
+    # their marker lines so every slice parses standalone. Used only by
+    # the errors: :collect fallback — a stream that parses whole never
+    # splits (the fallback's lossy cases are the whole reason #881
+    # exists; the good path must stay exact).
+    STREAM_MARKER = /\A(?:---|\.\.\.)(?:[ \t]|\r?\n|\z)/
+
+    # The marker-delimited slices of a stream. A slice that began at a
+    # marker line always survives (a trailing bare `---` is an empty
+    # document — nil, like psych yields); only a comments/blank-only
+    # leading prefix (no document) drops.
+    def _stream_slices(yaml)
+      slices = []
+      current = +""
+      markered = false
+      yaml.each_line do |line|
+        if line.match?(STREAM_MARKER)
+          slices << current if markered || !current.strip.empty?
+          current = line.dup
+          markered = true
+        else
+          current << line
+        end
+      end
+      slices << current if markered || !current.strip.empty?
+      slices
+    end
+
+    # The errors: :collect fallback: parse marker-boundary slices
+    # through the full stream face; a failed slice's position carries
+    # the ParseError. Documents before the bad one still load — the
+    # per-document rescue-and-skip contract, centralized.
+    def _collect_stream(yaml, schema)
+      results = []
+      _stream_slices(yaml).each do |slice|
+        begin
+          results.concat(_drain_all(slice, schema))
+        rescue ParseError => e
+          results << e
+        end
+      end
+      results
     end
 
     # The Marshal fast path when the loaded libyeptris has it (>= 0.1.11

data/lib/yeptris.rb

@@ -3,7 +3,7 @@
 module Yeptris
   # The gem's version lives in the parent namespace's file — the last
   # internal require (yeptris/version) retired with it.
-  VERSION = "0.6.56.1".freeze
+  VERSION = "0.6.58.1".freeze
 
   # Informational notices are OPT-IN (yeptris-ruby#217): consumers
   # embed yeptris inside CLIs that assert clean stderr, and a

data/vendor/libyeptris/CMakeLists.txt

@@ -3,7 +3,7 @@
 cmake_minimum_required(VERSION 3.20)
 
 project(yeptris
-    VERSION 0.6.56
+    VERSION 0.6.58
     DESCRIPTION "Ultra-fast YAML 1.2 parser, emitter and streamer in C"
     LANGUAGES C CXX
 )

data/vendor/libyeptris/src/CMakeLists.txt

@@ -39,9 +39,13 @@ set(YEPTRIS_SOURCES
     yeptris/resolve/tags.c
     yeptris/resolve/core12.c
     yeptris/resolve/compat11.c
+    yeptris/resolve/json12.c
     yeptris/parse/numbers.c
     yeptris/events/values.c
     yeptris/schema.c
+    yeptris/validate/regexp.c
+    yeptris/validate/validate.c
+    yeptris/validate/jsonschema.c
     yeptris/tape.c
     yeptris/plan.c
 
@@ -95,6 +99,7 @@ set(YEPTRIS_PUBLIC_HEADERS
     ${CMAKE_CURRENT_SOURCE_DIR}/include/yeptris/parse.h
     ${CMAKE_CURRENT_SOURCE_DIR}/include/yeptris/values.h
     ${CMAKE_CURRENT_SOURCE_DIR}/include/yeptris/schema.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/include/yeptris/validate.h
     ${CMAKE_CURRENT_SOURCE_DIR}/include/yeptris/tape.h
     ${CMAKE_CURRENT_SOURCE_DIR}/include/yeptris/plan.h
     ${CMAKE_CURRENT_SOURCE_DIR}/include/yeptris/marshal.h

data/vendor/libyeptris/src/include/yeptris/error.h

@@ -25,7 +25,8 @@ typedef enum {
     YEPTRIS_ERROR_ARG = 6,         /* invalid argument (NULL handle, bad option) */
     YEPTRIS_ERROR_UNSUPPORTED = 7, /* requested feature not built in */
     YEPTRIS_ERROR_INTERNAL = 8,    /* invariant violation — a bug, please report */
-    YEPTRIS_ERROR_SCHEMA = 9, /* descriptor materialization: a REQUIRED node missing (issue #238) */
+    YEPTRIS_ERROR_SCHEMA = 9,      /* validation: the report carries diagnostics (#882);
+                                    * descriptor materialization: REQUIRED missing (#238) */
 } YeptrisStatus;
 
 /* Message of the most recent failure on the calling thread, with its

data/vendor/libyeptris/src/include/yeptris/events.h

@@ -141,6 +141,13 @@ YEPTRIS_API YeptrisStatus yeptris_recorder_feed(YeptrisRecorder rec, const char*
  * the next feed; reset at every feed entry (drain per chunk). */
 YEPTRIS_API const YeptrisEventRecord* yeptris_recorder_records(YeptrisRecorder rec, size_t* count);
 YEPTRIS_API const char* yeptris_recorder_arena(YeptrisRecorder rec, size_t* len);
+
+/* Status of the last feed with its 1-based error position (0 = the
+ * failure carries no position, e.g. a capture allocation failure).
+ * Mirror of yeptris_pull_status / yeptris_iterparse_status. */
+YEPTRIS_API YeptrisStatus yeptris_recorder_status(const YeptrisRecorder rec, uint32_t* line,
+                                                  uint32_t* col);
+
 YEPTRIS_API void yeptris_recorder_free(YeptrisRecorder rec);
 
 /* ---- iterparse -------------------------------------------------------- */

data/vendor/libyeptris/src/include/yeptris/resolve.h

@@ -40,10 +40,12 @@ typedef enum {
     YEPTRIS_TAG_CUSTOM = 11,
 } YeptrisTagId;
 
-/* Schemas. */
+/* Schemas. Appending only — bindings hard-code the values (test_abi). */
 typedef enum {
     YEPTRIS_SCHEMA_12_CORE = 0, /* default: the yaml-test-suite target */
     YEPTRIS_SCHEMA_11_COMPAT,   /* libyaml/Psych implicit typing */
+    YEPTRIS_SCHEMA_12_JSON,     /* spec 10.2: JSON productions; plain
+                                 * scalars matching none are errors (#882) */
 } YeptrisSchema;
 
 /* Canonical tag URI for a core id ("tag:yaml.org,2002:str"); NULL for