yeptris 0.6.58.1-arm-linux-eabihf → 0.6.60.1-arm-linux-eabihf

data/lib/yeptris/yaml.rb

@@ -22,17 +22,64 @@ module Yeptris
     # schema: :compat_11 selects Psych/libyaml implicit typing
     # (yes/no, 0o/octal, sexagesimal); :core_12 (default) is YAML 1.2.
     #
+    # The validation keywords (#882) check BEFORE loading and raise
+    # Yeptris::Validation::Error carrying the diagnostics on invalid
+    # input: `validate:` rides the engine's schema-family walk (true
+    # rides :core_12 — the 1.2 families are the validation families;
+    # or an explicit :core_12 / :json_12), `json_schema:` validates
+    # against JSON Schema draft 2020-12 (schema bytes or a compiled
+    # Yeptris::Validation::Schema).
+    #
     # This surface keeps the Psych contract for EVERY input — including
     # JSON-shaped ones (`{"a": [1,]}` is legal flow YAML; `"1e3"` is a
     # Psych String). Strict RFC 8259 semantics live on Yeptris::JSON
     # (TODO.restructure/31): defaults follow proof, not benchmarks.
-    def load(yaml, schema: :compat_11)
+    def load(yaml, schema: :compat_11, validate: nil, json_schema: nil)
       yaml = Yeptris.read_input(yaml)
       yaml = yaml.to_s
+      _assert_valid(yaml, validate, json_schema) if validate || json_schema
       docs = _drain_all(yaml, schema)
       docs.empty? ? nil : docs.first
     end
 
+    # The validation face (#882): every diagnostic the engine reports,
+    # as plain Yeptris::Validation::Diagnostic values (empty array =
+    # valid). Default is the engine's core-family walk; `json_schema:`
+    # switches to JSON Schema draft 2020-12 (bytes or a compiled
+    # Yeptris::Validation::Schema), `validate:` picks the schema family
+    # explicitly (:core_12 / :json_12). Every document of the stream is
+    # validated; paths are root-relative per document.
+    def validate(yaml, validate: true, json_schema: nil)
+      yaml = Yeptris.read_input(yaml)
+      _validation_call(yaml.to_s, validate, json_schema)
+    end
+
+    # The boolean posture of validate: true when the engine reports no
+    # diagnostics.
+    def valid?(yaml, validate: true, json_schema: nil)
+      validate(yaml, validate: validate, json_schema: json_schema).empty?
+    end
+
+    # The load-side gate: raises Yeptris::Validation::Error carrying
+    # the diagnostics when the input is invalid; silent otherwise.
+    def _assert_valid(yaml, validate, json_schema)
+      diags = _validation_call(yaml, validate, json_schema)
+      raise Validation::Error, diags unless diags.empty?
+    end
+
+    def _validation_call(yaml, validate, json_schema)
+      if json_schema
+        Validation.validate_schema(yaml, json_schema)
+      else
+        # `validate: true` rides :core_12 — the family walk has no
+        # :compat_11 face (the engine rejects it; resolve schemas are
+        # not validation families).
+        Validation.validate_family(yaml, schema: validate == true ? :core_12 : validate)
+      end
+    end
+    private_class_method :_validation_call
+    private_class_method :_assert_valid
+
     # Psych-semantics safe_load on the native surface (issue #69 —
     # the entry frameworks actually want): plain data only; a leaf
     # whose class is not permitted raises Yeptris::Psych::
@@ -60,13 +107,23 @@ module Yeptris
     #
     # 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)
+    #
+    # The validation keywords (#882) run the whole stream BEFORE
+    # loading (the same shapes as load: `validate:` family walk /
+    # `json_schema:` JSON Schema 2020-12) and raise
+    # Yeptris::Validation::Error on any diagnostics. The engine's
+    # report is flat across the stream — diagnostics carry no
+    # per-document index (streaming validation is future work, #885) —
+    # so the verdict is whole-stream by construction.
+    def load_stream(yaml, schema: :compat_11, errors: :raise, validate: nil,
+                    json_schema: nil, &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
+      _assert_valid(yaml, validate, json_schema) if validate || json_schema
       docs =
         begin
           docs = _drain_all(yaml, schema)
@@ -140,6 +197,67 @@ module Yeptris
       results
     end
 
+    # The engine capability behind each_document (the CBOR.available?
+    # pattern): false when the loaded libyeptris predates the stream
+    # iterator — the walk itself raises the stale-engine message at use.
+    def each_document?
+      FFI::STREAM_ITER
+    end
+
+    # The tolerant per-document walk (engine #921): every document of
+    # the stream reaches the block IN STREAM ORDER — a valid document
+    # yields (document, nil); a failed document yields (nil, error)
+    # and the walk CONTINUES at the next line-start marker, so the
+    # valid documents after a bad one are kept (load_stream with
+    # errors: :raise would drop the whole stream; :collect recovers by
+    # a regex slice split, which quoted scalars spanning marker-looking
+    # lines can defeat — the engine iterator frames scanner-accurately,
+    # so those documents fail as ONE unit instead of splitting).
+    # Errors carry the failed document's own line/column and its
+    # stream index. Without a block, an Enumerator over the pairs.
+    def each_document(yaml, schema: :compat_11, max_depth: 0, &block)
+      return enum_for(:each_document, yaml, schema: schema, max_depth: max_depth) unless block
+
+      yaml = Yeptris.read_input(yaml)
+      yaml = yaml.to_s
+      opts = FFI::ParseOptions.new
+      opts[:schema] = schema == :compat_11 ? FFI::SCHEMA_11_COMPAT : FFI::SCHEMA_12_CORE
+      opts[:max_depth] = max_depth
+      it = FFI.yeptris_stream_iter_new(yaml, yaml.bytesize, opts)
+      doc_p = ::FFI::MemoryPointer.new(:pointer)
+      idx_p = ::FFI::MemoryPointer.new(:size_t)
+      line_p = ::FFI::MemoryPointer.new(:uint32)
+      col_p = ::FFI::MemoryPointer.new(:uint32)
+      begin
+        loop do
+          st = FFI.yeptris_stream_iter_next(it, doc_p, idx_p)
+          doc_ptr = doc_p.read_pointer
+          break if st == FFI::OK && doc_ptr.null? # the stream is over
+
+          index = FFI.read_c_size_t(idx_p)
+          if st == FFI::OK
+            doc = Document.without_finalizer(doc_ptr)
+            begin
+              yield doc.to_ruby, nil
+            ensure
+              doc.free
+            end
+          else
+            FFI.yeptris_stream_iter_status(it, line_p, col_p)
+            reason = st == FFI::ERROR_DEPTH ? "depth limit exceeded" : "parse error"
+            yield nil,
+                  ParseError.new(
+                    "stream document #{index}: #{reason} at line #{line_p.read_uint32}, " \
+                    "column #{col_p.read_uint32}"
+                  )
+            break if st == FFI::ERROR_MEMORY || st == FFI::ERROR_ENCODING
+          end
+        end
+      ensure
+        FFI.yeptris_stream_iter_free(it)
+      end
+    end
+
     # The Marshal fast path when the loaded libyeptris has it (>= 0.1.11
     # era builds), falling back to the columnar drain and finally the
     # record drain — one code path, the fastest the library offers.
@@ -176,8 +294,11 @@ module Yeptris
     # (TODO.impl/11 phase 3). Strings are emitted plain only when the
     # resolver round-trips them as strings — everything else takes a
     # quoted style, so dump(load(x)) == x for the scalar types.
-      def dump(obj, canonical: false, header: false)
-      BulkBuilder.dump(obj, canonical: canonical, header: header)
+    # width: the emitter's best_width (the engine wraps flow
+    # collections after a value when the line exceeds it; 0/nil rides
+    # the engine default of 80 — emit.h 13B).
+      def dump(obj, canonical: false, header: false, width: nil)
+      BulkBuilder.dump(obj, canonical: canonical, header: header, width: width)
     end
 
 
@@ -228,7 +349,7 @@ module Yeptris
                      Yeptris::FFI::BUILD_SEQ => SEQ_ENTRY,
                      Yeptris::FFI::BUILD_END => END_ENTRY }.freeze
 
-      def dump(obj, canonical: false, header: false)
+      def dump(obj, canonical: false, header: false, width: nil)
         parts = []
         blob = String.new(encoding: Encoding::BINARY)
         off = [0]
@@ -243,7 +364,8 @@ module Yeptris
         bblob = ::FFI::MemoryPointer.from_string(blob)
         rc = doc.build_entries(buf, parts.length, bblob, blob.bytesize)
         raise DumpError, "document_build failed: #{rc}" unless rc == FFI::OK
-        doc.serialize(canonical: canonical, explicit_doc_start: header)
+        doc.serialize(canonical: canonical, best_width: width || 0,
+                      explicit_doc_start: header)
       ensure
         doc&.free
       end

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.58.1".freeze
+  VERSION = "0.6.60.1".freeze
 
   # Informational notices are OPT-IN (yeptris-ruby#217): consumers
   # embed yeptris inside CLIs that assert clean stderr, and a
@@ -54,6 +54,7 @@ module Yeptris
   autoload :ValueML, "yeptris/valueml"
   autoload :Psych, "yeptris/psych"
   autoload :Schema, "yeptris/schema"
+  autoload :Validation, "yeptris/validation"
   autoload :CBOR, "yeptris/cbor"
 end
 

data/vendor/libyeptris/CMakeLists.txt

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

data/vendor/libyeptris/src/CMakeLists.txt

@@ -29,6 +29,7 @@ set(YEPTRIS_SOURCES
     yeptris/dom/mapindex.c
     yeptris/dom/mutate.c
     yeptris/parse.c
+    yeptris/parse/stream_iter.c
     yeptris/build.c
     yeptris/events/capture.c
     yeptris/events/push.c
@@ -40,16 +41,23 @@ set(YEPTRIS_SOURCES
     yeptris/resolve/core12.c
     yeptris/resolve/compat11.c
     yeptris/resolve/json12.c
+    yeptris/resolve/full12.c
     yeptris/parse/numbers.c
     yeptris/events/values.c
     yeptris/schema.c
     yeptris/validate/regexp.c
     yeptris/validate/validate.c
+    yeptris/validate/compile.c
+    yeptris/validate/resources.c
     yeptris/validate/jsonschema.c
+    yeptris/validate/registry.c
+    yeptris/validate/output.c
+    yeptris/validate/stream.c
     yeptris/tape.c
     yeptris/plan.c
 
     yeptris/marshal.c
+    yeptris/marshal/to_json.c
     yeptris/visit/json_visit.c
     yeptris/visit/yaml_visit.c
     yeptris/visit/dom_visit.c

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

@@ -24,7 +24,14 @@ extern "C" {
 #endif
 
 /* Emission options (13B). Versioned by size: initialize with
- * {sizeof(yeptris_emit_options)} so future fields stay optional. */
+ * {sizeof(yeptris_emit_options)} so future fields stay optional.
+ *
+ * Deliberately omitted: a flowLevel knob (libyaml's best_width +
+ * default_flow_style interplay). The engine's style chooser is
+ * recorded-style driven — flow is whatever the document recorded
+ * (plus the fixed canonical/JSON forms) — so there is no "switch to
+ * flow past level N" decision to expose; revisit only if a binding
+ * face actually needs PyYAML's default_flow_style mapping. */
 typedef struct yeptris_emit_options {
     uint32_t size;          /* sizeof(yeptris_emit_options) */
     int canonical;          /* fixed form: flow collections, quoted strings,
@@ -32,13 +39,34 @@ typedef struct yeptris_emit_options {
                              * output re-serializes byte-identically */
     int best_width;         /* 0 = library default (80): flow collections
                              * wrap after a value when the current line
-                             * exceeds the width (13B) */
+                             * exceeds the width (13B); with block_fold
+                             * it is also the fold column for block
+                             * scalars (#903) */
     int explicit_doc_start; /* nonzero: every document carries the
                              * leading --- marker (Psych/libyaml's
                              * implicit=false parity). Default 0: a
                              * single document is emitted bare. Only
                              * read when the caller's struct is large
                              * enough (size-versioned). */
+    int best_indent;        /* (#903) block indentation per level: the
+                             * content column of a nested block mapping
+                             * and the "- " item level. Out of range
+                             * (< 2 or > 9, libyaml's clamp) or 0 = the
+                             * library default 2. Only read when the
+                             * caller's struct is large enough. */
+    int block_fold;         /* (#903) nonzero: plain and single-quoted
+                             * scalars in block context fold at
+                             * best_width the way libyaml/Psych/PyYAML
+                             * do — at an interior single space past the
+                             * width the break replaces the space and
+                             * the continuation re-indents to
+                             * parent_col + best_indent. Default 0:
+                             * block output is width-invariant (byte-
+                             * identical with releases before the
+                             * option). Keys and flow members never
+                             * fold; canonical/JSON keep their fixed
+                             * forms. Only read when the caller's
+                             * struct is large enough. */
 } yeptris_emit_options;
 
 /* Options-aware entries; opts == NULL selects the fidelity mode

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

@@ -41,6 +41,58 @@ YEPTRIS_API YeptrisDocument yeptris_parse_ex(const char* buf, size_t len,
                                              const YeptrisParseOptions* opts,
                                              YeptrisStatus* status);
 
+/* ---- tolerant per-document stream iteration (#921) ----------------------
+ *
+ * load_stream parses the whole stream and aborts on the first bad
+ * document; this iterator frames documents engine-side (the abort-at-
+ * DOCUMENT_END run — scanner-accurate: a quoted scalar spanning a
+ * marker-looking line never splits) and reports failures PER DOCUMENT:
+ * a parse-class error surfaces as the step's status with NULL *out, the
+ * error channel carrying the failed document's own line/col (each run
+ * starts at the frame), and the iterator resynced to the next line-
+ * start marker — the host keeps calling and keeps the valid documents.
+ *
+ *   yeptris_stream_iter* it = yeptris_stream_iter_new(buf, len, &opts);
+ *   YeptrisDocument doc;
+ *   size_t index;
+ *   YeptrisStatus st;
+ *   while ((st = yeptris_stream_iter_next(it, &doc, &index)) == YEPTRIS_OK && doc != NULL) {
+ *       // doc is document `index` of the stream; free it with
+ *       // yeptris_document_free
+ *   }
+ *   // st == OK && doc == NULL: the stream is over; st != OK: document
+ *   // `index` failed (per-document line/col via
+ *   // yeptris_stream_iter_status), keep iterating.
+ *
+ * Memory: the caller owns each *out (yeptris_document_free). The
+ * iterator borrows `buf` until free. Each document parses twice (the
+ * boundary run + the slice parse) — the tolerance contract is the
+ * point; a single-pass upgrade rides the same seam when needed.
+ */
+typedef struct yeptris_stream_iter yeptris_stream_iter;
+
+/* The iterator borrows `buf` until free; `opts` is borrowed (may be
+ * NULL: the 12_CORE defaults). NULL on arg/alloc failure. */
+YEPTRIS_API yeptris_stream_iter* yeptris_stream_iter_new(const char* buf, size_t len,
+                                                         const YeptrisParseOptions* opts);
+
+/* The next document: OK + *out = the document (the caller frees it);
+ * a parse/DEPTH-class DOCUMENT failure: that status + *out = NULL +
+ * the error channel set for THAT document — the iterator has already
+ * resynced, keep calling; OK + *out = NULL: the stream is over;
+ * MEMORY/ENCODING: stream-fatal, the iterator is done. *index (may be
+ * NULL) is the 0-based stream document index this step consumed
+ * (failures consume an index too — the yield order is the stream's). */
+YEPTRIS_API YeptrisStatus yeptris_stream_iter_next(yeptris_stream_iter* it, YeptrisDocument* out,
+                                                   size_t* index);
+
+/* The LAST step's per-document verdict and its 1-based line/col
+ * (0/0 when the last step was a success or the stream end). */
+YEPTRIS_API YeptrisStatus yeptris_stream_iter_status(const yeptris_stream_iter* it, uint32_t* line,
+                                                     uint32_t* col);
+
+YEPTRIS_API void yeptris_stream_iter_free(yeptris_stream_iter* it);
+
 #ifdef __cplusplus
 }
 #endif

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

@@ -46,6 +46,14 @@ typedef enum {
     YEPTRIS_SCHEMA_11_COMPAT,   /* libyaml/Psych implicit typing */
     YEPTRIS_SCHEMA_12_JSON,     /* spec 10.2: JSON productions; plain
                                  * scalars matching none are errors (#882) */
+    YEPTRIS_SCHEMA_12_FULL,     /* the full 1.2 family (#906 slice 3):
+                                 * core typing + RFC3339-era timestamps
+                                 * (spec 2.22's four forms; the yaml.org
+                                 * type repository carried forward) and
+                                 * the merge/value words; !!binary rides
+                                 * as passthrough. A validation family:
+                                 * explicit !!timestamp content must
+                                 * re-resolve through the classifier. */
 } YeptrisSchema;
 
 /* Canonical tag URI for a core id ("tag:yaml.org,2002:str"); NULL for