yang_json 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: fa4c5688935f52cb5b7f4c19617c931412a8292e80ae74172f9038f8ce2b51a1
+  data.tar.gz: c37fa39548ca49e450eba98cb78d3d15c84cf64de1387cb35294327ab92e266b
+SHA512:
+  metadata.gz: 86e6486fcc19d66b68bc9b65e904f748557e24e5c19dde37fc3c00c0c8c2c27205570b0db297666feac0dda9cf055926bbd30c590a2268c631a8c05a520ee2f7
+  data.tar.gz: 78bf06358c8d754cf5614e1ff69f1eca28787c325453390fb576851e65d191d462f99ab1eee926a96f5fe44b6aee028aafe787748b892cff4279c0514bcb5a6f

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+# Changelog
+
+## 0.1.0 - 2026-10-12
+
+Initial release.

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Yudai Takada
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,110 @@
+# yang_json
+
+Read, validate and write [RFC 7951](https://www.rfc-editor.org/rfc/rfc7951) YANG JSON in Ruby, including [RFC 7952](https://www.rfc-editor.org/rfc/rfc7952) metadata. Supply a schema as a Ruby Hash or JSON document. No external schema compiler, YANG parser, or subprocess is required.
+
+## Installation
+
+```ruby
+gem "yang_json", "~> 0.1.0"
+```
+
+Ruby 3.3 or later, JRuby and TruffleRuby are tested. Runtime dependencies are `json` (2.19.4–3.x), `bigdecimal` and `base64`; no other gem in this family is required. JSON 2.x and 3.x both reject duplicate object members explicitly.
+
+## Schema and data
+
+Define the nodes and their types directly, or load the same structure with `Schema.from_json`. See [schema format](docs/jtox-format.md).
+
+```ruby
+require "yang_json"
+
+schema = YangJSON::Schema.new({
+  "modules" => { "orchard" => ["o", "urn:example:orchard"] },
+  "tree" => { "orchard:grove" => ["container", { "count" => ["leaf", "uint64"] }] },
+  "annotations" => {}
+})
+data = YangJSON.decode('{"orchard:grove":{"count":"123"}}', schema)
+data["orchard:grove"]["orchard:count"] # => 123
+YangJSON.encode(data, schema)           # => '{"orchard:grove":{"count":"123"}}'
+schema.lookup("/orchard:grove/count").type # => "uint64"
+YangJSON.validate('{"orchard:grove":{"count":123}}', schema).first.pointer
+# => "/orchard:grove/count"
+```
+
+`decode` returns a mutable `YangJSON::Document`, a Hash with `warnings` and `union_members`. All modeled Ruby keys are **module-qualified**, including descendants. `encode` requires that form and writes the minimally qualified names required by RFC 7951. Opaque `anydata`/`anyxml` content retains its wire names. The schema and its nodes are immutable and shareable; conversions do not mutate inputs. `YangJson` is an alias for `YangJSON`.
+
+`YangJSON.parse(json, schema: schema)` is an alternate spelling of `decode`. `schema.lookup` accepts a slash-separated path or an array of names; descendants may use simple or qualified names. List nodes expose their qualified `keys`.
+
+## Values
+
+| YANG type | Ruby value | JSON representation |
+|---|---|---|
+| int8/int16/int32, uint8/uint16/uint32 | Integer, within the type's range | Number |
+| int64, uint64 | Integer, within the type's range | Decimal string |
+| decimal64 | BigDecimal, exact scaled 64-bit value | Decimal string |
+| string, enumeration | Unicode String | String |
+| boolean | true / false | true / false |
+| bits | Array of unique names | Whitespace-separated string |
+| binary | ASCII-8BIT String (`bytes.b`) | Standard padded base64 |
+| identityref | Module-qualified String | Local name or qualified name |
+| empty | true | `[null]` |
+| union | Native value of a matching member | Matching member's JSON type |
+| instance-identifier | String | Absolute path with module-name qualification |
+| leafref | Native value of the resolved target type | Target type's representation |
+| anydata | Hash of opaque JSON values | Object subject to RFC 7951 §5.5 |
+| anyxml | Opaque JSON value | I-JSON value |
+
+Decimal strings normalize on encoding (`"12.30"` becomes `"12.3"`, negative zero becomes `"0.0"`). Integer signs/leading zeros, bit whitespace and local identity prefixes also normalize. Binary decoding requires canonical padding and zero pad bits. Integer JSON tokens containing fractions/exponents are not accepted as small integer values.
+
+Unions try compatible members in schema order, using the JSON type during decoding. Documents remember the selected member at each path, so JSON `1` and `"1"` remain distinct even when both become Ruby Integers. Plain Hash inputs use the first compatible member. Moving values to different paths, reordering arrays, or discarding the Document can discard this original selection; select unambiguous schema members when that distinction matters.
+
+Metadata uses `@` inside container/list-entry/anydata objects, or `@module:leaf` beside modeled native leaves, anyxml and leaf-lists. Annotation names always stay qualified, and values use their declared types. Leaf-list metadata arrays preserve null holes and may omit trailing nulls. Registered annotations within opaque anydata are converted; its data values otherwise remain in wire form.
+
+## Validation and limits
+
+```ruby
+data = YangJSON.decode(json, schema, strict: false)
+data.warnings.each { |violation| warn "#{violation.pointer}: #{violation.message}" }
+```
+
+Strict decoding raises `ValidationError`; lenient decoding retains unknown or invalid values and attaches diagnostics. It does not make invalid configuration safe. Encoding is always strict. Unknown schema fields cannot be serialized until the schema is extended or the fields are removed. Modeled keys normalize in lenient results, so malformed namespace aliases cannot always be preserved independently.
+
+`ValidationError#violations` contains `Violation` objects with `pointer`, `message` and `rule`; `ValidationError#pointer` identifies the first failure. Pointers address the input document. `validate` returns violations, including parse failures. `ParseError` covers malformed JSON/schemas and resource limits; `ConversionError` covers generation errors. All inherit from `YangJSON::Error`. Unknown options, nonpositive limits and invalid schema arguments raise `ArgumentError`.
+
+| Option | Default | Applies to |
+|---|---:|---|
+| `max_bytes` | 16 MiB | Input/output JSON; aggregate native string/key bytes |
+| `max_depth` | 32 | JSON/native/schema nesting |
+| `max_nodes` | 100,000 | Total values visited |
+| `max_items` | 10,000 | Members of an object or items of an array |
+| `max_binary_bytes` | 1 MiB | Decoded/encoded binary payload |
+
+Pass overrides to `decode`, `encode`, `parse`, `validate` or `Schema.from_json`. Integer/decimal strings have an additional 128-character bound. Invalid Unicode, noncharacters, nonfinite numbers and duplicate members always fail, including lenient mode. Opaque integer values are restricted to ±(2^53−1); represent larger numbers as strings. Large objects, cyclic Ruby data and deep nesting are rejected before recursive conversion can exhaust normal limits.
+
+## Scope
+
+| Supported | Outside the 0.1 scope |
+|---|---|
+| RFC 7951 names, all built-in value encodings, containers/lists, key presence and duplicate key tuples | Parsing YANG/YIN; XML, NETCONF and RESTCONF transport APIs |
+| Pre-resolved built-in types, leafrefs, union members, and augmented nodes supplied by the caller | Compiling YANG typedefs, uses, augment, choice, RPC, action or notification definitions |
+| Exact decimal64, 64-bit integers, union member selection and identity namespace rules | Complete YANG semantic/datastore validation |
+| RFC 7952 typed annotations on each node category | Interpreting annotation application semantics |
+| Structural schema-less anydata validation and opaque anyxml | Inferring or resolving schemas inside opaque content |
+
+**The schema format omits semantic constraints.** This gem cannot validate enumeration membership, identity derivation, allowed bit names/positions, derived range/length/pattern restrictions, mandatory/default/config properties, choice exclusivity, min/max-elements, unique statements, must/when expressions, leafref existence or instance-identifier existence. It does not add defaults or reorder system-ordered collections. Repeated leaf-list values are accepted because state leaf-lists may contain duplicates and the schema omits `config`. Instance-identifier syntax and namespace changes are checked, but node existence and predicate suitability are not resolved. See [schema format notes](docs/jtox-format.md).
+
+## Development and conformance
+
+```sh
+bundle install
+bundle exec rake test
+COVERAGE=1 bundle exec rake test
+bundle exec rbs -r bigdecimal -I sig validate
+```
+
+The Ruby suite covers all 20 JSON/path examples in RFC 7951/7952, including the deliberately invalid union value and complete Appendix A. Test schemas are declared locally. RFC excerpts are fetched with pinned SHA-256 hashes into ignored `tmp/rfc/`, retaining source notices and extraction corrections. These documents and examples are test inputs, never dependencies or packaged files. No external implementation is downloaded or executed by the tests. See [conformance notes](docs/conformance.md).
+
+`bundle exec ruby script/benchmark.rb` measures a bounded large record and limit rejection. CI tests maintained CRuby versions, head, JRuby and TruffleRuby on Linux/macOS, and both JSON major versions. Coverage must reach 90%.
+
+## License and security
+
+Released under the [MIT License](LICENSE.txt). Added runtime and development dependencies must offer MIT terms; Ruby, its standard libraries and their system dependencies are the explicit exception. See [implementation and dependency policy](docs/implementation.md). Report vulnerabilities through the private channel in [SECURITY.md](SECURITY.md).

data/SECURITY.md

@@ -0,0 +1,12 @@
+# Security
+
+Report vulnerabilities privately through [GitHub security advisories](https://github.com/ydah/yang_json/security/advisories/new).
+Include the Ruby/json versions, a minimal schema and input, and the observed impact. Do not include credentials or private configuration data.
+
+The 0.1.x series receives security fixes. This gem converts RFC 7951 data using a caller-supplied schema; it does not authenticate input, execute XPath, resolve remote modules, or implement complete YANG datastore validation. Use a full YANG validator when semantic constraints are required.
+
+JSON member duplication, invalid UTF-8/noncharacters, nonfinite numbers, malformed metadata, and structure/type violations are rejected. Encoding always validates. Lenient decoding preserves unsupported values with warnings and must not be treated as accepted configuration. Review `warnings` before using such data.
+
+Byte, nesting, node, collection and binary limits apply before or during conversion. Schema loading is also bounded. Raising these limits increases resource exposure. Pass trusted schemas and limits; protect application-level request sizes and concurrency separately. `anyxml` and schema-less `anydata` are opaque data, never executable XML or code.
+
+Conformance documents and their notices are downloaded into ignored `tmp/` only. External implementations are not downloaded or executed by the tests. They are excluded from Git and the gem package. Dependencies retain their own licenses.

data/data/encoding.yml

@@ -0,0 +1,21 @@
+# Original encoding reference; normative rules are cited, not reproduced.
+names: {rfc: '7951', section: '4', ruby: 'qualified String keys', json: 'minimal module qualification'}
+container: {rfc: '7951', section: '5.2', ruby: Hash, json: object}
+leaf-list: {rfc: '7951', section: '5.3', ruby: Array, json: array}
+list: {rfc: '7951', section: '5.4', ruby: 'Array of Hash', json: 'array of objects'}
+anydata: {rfc: '7951', section: '5.5', ruby: 'Hash with opaque content', json: object}
+anyxml: {rfc: '7951', section: '5.6', ruby: 'JSON-compatible value', json: 'I-JSON value'}
+int8_int16_int32_uint8_uint16_uint32: {rfc: '7951', section: '6.1', ruby: Integer, json: number}
+int64_uint64: {rfc: '7951', section: '6.1', ruby: Integer, json: string}
+decimal64: {rfc: '7951', section: '6.1', ruby: BigDecimal, json: string}
+string: {rfc: '7951', section: '6.2', ruby: String, json: string}
+boolean: {rfc: '7951', section: '6.3', ruby: boolean, json: boolean}
+enumeration: {rfc: '7951', section: '6.4', ruby: String, json: string}
+bits: {rfc: '7951', section: '6.5', ruby: 'Array of String', json: string}
+binary: {rfc: '7951', section: '6.6', ruby: 'ASCII-8BIT String', json: 'base64 string'}
+leafref: {rfc: '7951', section: '6.7', ruby: 'resolved referent type', json: 'resolved referent type'}
+identityref: {rfc: '7951', section: '6.8', erratum: 7020, ruby: 'module-qualified String', json: string}
+empty: {rfc: '7951', section: '6.9', ruby: 'true', json: '[null]'}
+union: {rfc: '7951', section: '6.10', ruby: 'native member type', json: 'selected member type'}
+instance-identifier: {rfc: '7951', section: '6.11', ruby: String, json: string}
+metadata: {rfc: '7952', section: '5.2', ruby: 'typed annotations', json: 'annotation object or positional array'}

data/lib/yang_json/core.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require "json"
+require "base64"
+require "bigdecimal"
+
+module YangJSON
+  class Error < StandardError; end
+  class ParseError < Error; end
+  Violation = Data.define(:pointer, :message, :rule)
+
+  class ValidationError < Error
+    attr_reader :violations, :pointer
+
+    def initialize(violations)
+      @violations = violations.freeze
+      @pointer = violations.first&.pointer || ""
+      super(violations.first&.message || "Invalid YANG data")
+    end
+  end
+
+  class ConversionError < Error; end
+
+  class Document < Hash
+    attr_reader :warnings, :union_members
+
+    def initialize(values, warnings:, union_members: {})
+      super()
+      update(values)
+      @warnings = warnings.freeze
+      @union_members = union_members.freeze
+    end
+  end
+
+  module Core
+    IDENTIFIER = /\A[A-Za-z_][A-Za-z0-9_.-]*\z/
+    NAME = /\A(?:[A-Za-z_][A-Za-z0-9_.-]*:)?[A-Za-z_][A-Za-z0-9_.-]*\z/
+    DEFAULTS = { max_bytes: 16 * 1024 * 1024, max_depth: 32, max_nodes: 100_000, max_items: 10_000, max_binary_bytes: 1024 * 1024 }.freeze
+
+    module_function
+
+    def limits(options)
+      unknown = options.keys - DEFAULTS.keys
+      raise ArgumentError, "Unknown limit option" unless unknown.empty?
+
+      result = DEFAULTS.merge(options)
+      raise ArgumentError, "Limits must be positive integers" unless result.values.all? { |value| value.is_a?(Integer) && value.positive? }
+
+      result.freeze
+    end
+
+    def pointer(parent, name)
+      "#{parent}/#{name.to_s.gsub("~", "~0").gsub("/", "~1")}"
+    end
+
+    def parse(source, limits)
+      raise ParseError, "JSON source must be a string" unless source.is_a?(String)
+      raise ParseError, "Input byte limit exceeded" if source.bytesize > limits[:max_bytes]
+
+      source = source.dup.force_encoding(Encoding::UTF_8)
+      raise ParseError, "Invalid UTF-8" unless source.valid_encoding?
+
+      result = JSON.parse(source, allow_duplicate_key: false, max_nesting: limits[:max_depth], allow_nan: false)
+      copy(result, limits)
+    rescue JSON::ParserError, EncodingError, ArgumentError
+      raise ParseError, "Invalid JSON", cause: nil
+    end
+
+    def string(value)
+      return false unless value.is_a?(String) && value.valid_encoding? && (value.encoding == Encoding::UTF_8 || value.ascii_only?)
+
+      value.each_codepoint.none? { |point| (0xFDD0..0xFDEF).cover?(point) || (point & 0xFFFF) >= 0xFFFE }
+    end
+
+    def copy(value, limits = DEFAULTS, native: false, depth: 0, budget: [0, 0])
+      budget[0] += 1
+      raise ParseError, "Node count limit exceeded" if budget[0] > limits[:max_nodes]
+      raise ParseError, "Nesting limit exceeded" if depth > limits[:max_depth]
+
+      case value
+      when Hash
+        raise ParseError, "Object member limit exceeded" if value.length > limits[:max_items]
+        raise ParseError, "Invalid JSON member name" unless value.keys.all? { |name| string(name) }
+
+        budget[1] += value.keys.sum(&:bytesize)
+        raise ParseError, "Aggregate string byte limit exceeded" if budget[1] > limits[:max_bytes]
+
+        value.to_h { |name, item| [name.dup, copy(item, limits, native: native, depth: depth + 1, budget: budget)] }
+      when Array
+        raise ParseError, "Array item limit exceeded" if value.length > limits[:max_items]
+
+        value.map { |item| copy(item, limits, native: native, depth: depth + 1, budget: budget) }
+      when String
+        raise ParseError, "Invalid Unicode string" unless (native && value.encoding == Encoding::ASCII_8BIT) || string(value)
+
+        budget[1] += value.bytesize
+        raise ParseError, "String byte limit exceeded" if budget[1] > limits[:max_bytes]
+
+        value.dup
+      when Float
+        raise ParseError, "Non-finite number" unless value.finite?
+
+        value
+      when BigDecimal
+        raise ParseError, "Unexpected decimal object" unless native && value.finite?
+
+        value
+      when Integer, TrueClass, FalseClass, NilClass then value
+      else raise ParseError, "Unsupported Ruby value"
+      end
+    end
+
+    def freeze_tree(value)
+      case value
+      when Hash then value.each do |key, item|
+        key.freeze
+        freeze_tree(item)
+      end
+      when Array then value.each { |item| freeze_tree(item) }
+      end
+      value.freeze
+    end
+
+    def precise(value)
+      case value
+      when Hash then value.transform_values { |item| precise(item) }
+      when Array then value.map { |item| precise(item) }
+      when Float
+        return value unless RUBY_ENGINE == "truffleruby"
+
+        number = format("%.17g", value)
+        number += ".0" unless number.match?(/[.eE]/)
+        JSON::Fragment.new(number)
+      else value
+      end
+    end
+  end
+end

data/lib/yang_json/schema.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+module YangJSON
+  class Node
+    attr_reader :name, :module_name, :kind, :type, :children, :keys
+
+    def initialize(name:, kind:, type: nil, children: {}, keys: [])
+      @name = name.freeze
+      @module_name = name.split(":", 2).first.freeze
+      @kind = kind.freeze
+      @type = Core.freeze_tree(type)
+      @children = children.freeze
+      @keys = Core.freeze_tree(keys)
+      freeze
+    end
+  end
+
+  class Schema
+    attr_reader :modules, :tree, :annotations
+
+    # @param source [String] a schema in the documented JSON format
+    # @return [Schema] immutable schema
+    def self.from_json(source, **options)
+      limits = Core.limits(options)
+      new(Core.parse(source, limits), limits: limits)
+    end
+
+    class << self
+      alias from_jtox from_json
+    end
+
+    def initialize(data, limits: Core::DEFAULTS)
+      raise ParseError, "jtox schema must contain modules, tree, and annotations" unless data.is_a?(Hash) && %w[modules tree annotations].all? do |key|
+        data[key].is_a?(Hash)
+      end
+
+      data = Core.copy(data, limits)
+      @modules = data.fetch("modules")
+      @modules.each do |name, definition|
+        unless Core::IDENTIFIER.match?(name) && definition.is_a?(Array) && definition.length == 2 && definition.all?(String) && Core::IDENTIFIER.match?(definition[0])
+          raise ParseError, "Invalid jtox module definition"
+        end
+      end
+      @modules = Core.freeze_tree(@modules)
+      @tree = build_nodes(data.fetch("tree"), nil)
+      @annotations = data.fetch("annotations").to_h do |name, type|
+        qualified(name, nil)
+        check_type(type)
+        [name, Core.freeze_tree(type)]
+      end.freeze
+      freeze
+    end
+
+    # @param path [String, Array<String>] qualified root and simple/qualified descendants
+    # @return [Node, nil] schema node, or nil when absent
+    def lookup(path)
+      parts = path.is_a?(String) ? path.delete_prefix("/").split("/") : path
+      return nil unless parts.is_a?(Array)
+
+      nodes = tree
+      parent = nil
+      node = nil
+      parts.each do |part|
+        name = part.include?(":") ? part : "#{parent}:#{part}"
+        node = nodes[name]
+        return nil unless node
+
+        parent = node.module_name
+        nodes = node.children
+      end
+      node
+    end
+
+    private
+
+    def qualified(name, parent)
+      raise ParseError, "Invalid jtox node name" unless name.is_a?(String) && Core::NAME.match?(name)
+
+      full = name.include?(":") ? name : "#{parent}:#{name}"
+      raise ParseError, "Unknown or absent jtox module" unless modules.key?(full.split(":", 2).first)
+
+      full
+    end
+
+    def check_type(type)
+      if type.is_a?(String)
+        raise ParseError, "Unsupported or unresolved jtox type" unless Types::PRIMITIVES.include?(type)
+      elsif type.is_a?(Array) && type.length == 2
+        if type[0] == "decimal64"
+          raise ParseError, "Invalid fraction-digits" unless type[1].is_a?(Integer) && (1..18).cover?(type[1])
+        elsif type[0] == "union" && type[1].is_a?(Array) && !type[1].empty?
+          type[1].each { |member| check_type(member) }
+        else
+          raise ParseError, "Invalid jtox compound type"
+        end
+      else
+        raise ParseError, "Invalid jtox type"
+      end
+    end
+
+    def build_nodes(tree, parent)
+      raise ParseError, "Invalid jtox tree" unless tree.is_a?(Hash)
+
+      tree.each_with_object({}) do |(name, definition), output|
+        full = qualified(name, parent)
+        raise ParseError, "Duplicate normalized jtox node" if output.key?(full)
+        raise ParseError, "Invalid jtox node" unless definition.is_a?(Array)
+
+        kind = definition[0]
+        case kind
+        when "container", "list"
+          expected = kind == "list" ? 3 : 2
+          raise ParseError, "Invalid jtox branch" unless definition.length == expected
+
+          children = build_nodes(definition[1], full.split(":", 2).first)
+          keys = kind == "list" ? definition[2] : []
+          raise ParseError, "Invalid jtox list keys" unless keys.is_a?(Array) && keys.all? { |key| key.is_a?(Array) && key.length == 2 && key.all?(String) }
+
+          keys = keys.map { |key| key.join(":") }
+          raise ParseError, "List key must reference a child leaf" unless keys.uniq == keys && keys.all? { |key| children[key]&.kind == "leaf" }
+
+          output[full] = Node.new(name: full, kind: kind, children: children, keys: keys)
+        when "leaf", "leaf-list"
+          raise ParseError, "Invalid jtox leaf" unless definition.length == 2
+
+          check_type(definition[1])
+          output[full] = Node.new(name: full, kind: kind, type: definition[1])
+        when "anydata", "anyxml"
+          raise ParseError, "Invalid jtox opaque node" unless definition.length == 1
+
+          output[full] = Node.new(name: full, kind: kind)
+        else raise ParseError, "Unsupported jtox node kind"
+        end
+      end.freeze
+    end
+  end
+end

data/lib/yang_json/transformer.rb

@@ -0,0 +1,245 @@
+# frozen_string_literal: true
+
+module YangJSON
+  class Transformer
+    attr_reader :violations, :selections
+
+    def initialize(schema, mode:, limits:, selections: {})
+      raise ArgumentError, "Expected a YangJSON::Schema" unless schema.is_a?(Schema)
+
+      @schema = schema
+      @mode = mode
+      @limits = limits
+      @violations = []
+      @selections = selections.dup
+    end
+
+    def transform(value)
+      object(value, @schema.tree, nil, "", "", metadata_allowed: false)
+    end
+
+    private
+
+    def invalid(pointer, message, rule)
+      @violations << Violation.new(pointer: pointer.freeze, message: message.freeze, rule: rule.freeze)
+    end
+
+    def object(value, nodes, parent, pointer, location, metadata_allowed: true)
+      unless value.is_a?(Hash)
+        invalid(pointer, "Expected an object", "structure")
+        return value
+      end
+      output = {}
+      normalized = {}
+      value.each do |name, item|
+        next if name.start_with?("@")
+
+        path = Core.pointer(pointer, name)
+        unless Core::NAME.match?(name)
+          invalid(path, "Invalid YANG member name", "name")
+          output[name] = item
+          next
+        end
+        full = if name.include?(":")
+                 name
+               else
+                 (parent ? "#{parent}:#{name}" : name)
+               end
+        node = nodes[full]
+        unless node
+          invalid(path, "Unknown schema node", "schema")
+          output[full] = item
+          normalized[name] = [full, nil]
+          next
+        end
+        expected = @mode == :encode ? full : wire_name(node, parent)
+        invalid(path, "Invalid module qualification", "namespace") unless name == expected
+        target = @mode == :decode ? full : wire_name(node, parent)
+        if output.key?(target)
+          invalid(path, "Duplicate normalized member", "duplicate")
+          next
+        end
+        normalized[name] = [target, node]
+        output[target] = node_value(item, node, path, Core.pointer(location, full))
+      end
+      # Resolve data members first: metadata is allowed to precede its target.
+      value.each do |name, item| # rubocop:disable Style/CombinableLoops
+        next unless name.start_with?("@")
+
+        path = Core.pointer(pointer, name)
+        if name == "@"
+          invalid(path, "Metadata has no enclosing data node", "metadata") unless metadata_allowed
+          output[name] = annotations(item, path, Core.pointer(location, "@"))
+          next
+        end
+        target, node = normalized[name.delete_prefix("@")]
+        unless node
+          invalid(path, "Metadata must accompany an existing schema node", "metadata")
+          output[name] = item
+          next
+        end
+        if node.kind == "leaf-list"
+          if !item.is_a?(Array) || !value[name.delete_prefix("@")].is_a?(Array) || item.length > value[name.delete_prefix("@")].length
+            invalid(path, "Leaf-list metadata must align with its values", "metadata")
+            output["@#{target}"] = item
+          else
+            output["@#{target}"] = item.each_with_index.map do |entry, index|
+              entry.nil? ? nil : annotations(entry, Core.pointer(path, index), Core.pointer(location, "@#{node.name}/#{index}"))
+            end
+          end
+        elsif %w[leaf anyxml].include?(node.kind)
+          output["@#{target}"] = annotations(item, path, Core.pointer(location, "@#{node.name}"))
+        else
+          invalid(path, "Object node metadata belongs inside its @ member", "metadata")
+          output["@#{target}"] = item
+        end
+      end
+      output
+    end
+
+    def node_value(value, node, pointer, location)
+      case node.kind
+      when "container" then object(value, node.children, node.module_name, pointer, location)
+      when "list"
+        unless value.is_a?(Array)
+          invalid(pointer, "List must be an array", "structure")
+          return value
+        end
+        entries = value.each_with_index.map do |entry, index|
+          object(entry, node.children, node.module_name, Core.pointer(pointer, index), Core.pointer(location, index))
+        end
+        seen = {}
+        entries.each_with_index do |entry, index|
+          next unless entry.is_a?(Hash)
+
+          keys = node.keys.map { |name| @mode == :decode ? name : wire_name(node.children.fetch(name), node.module_name) }
+          missing = keys.reject { |key| entry.key?(key) }
+          missing.each do |key|
+            child = node.children.values.find { |candidate| candidate.name == key || wire_name(candidate, node.module_name) == key }
+            input_key = @mode == :decode ? wire_name(child, node.module_name) : child.name
+            invalid(Core.pointer(Core.pointer(pointer, index), input_key), "Required list key is missing", "key")
+          end
+          next unless missing.empty? && !keys.empty?
+
+          tuple = keys.map { |key| entry[key] }
+          invalid(Core.pointer(pointer, index), "Duplicate list key tuple", "unique") if seen[tuple]
+          seen[tuple] = true
+        end
+        entries
+      when "leaf" then typed(value, node.type, node.module_name, pointer, location)
+      when "leaf-list"
+        unless value.is_a?(Array)
+          invalid(pointer, "Leaf-list must be an array", "structure")
+          return value
+        end
+        # jtox omits config; YANG 1.1 permits repeated values for state leaf-lists.
+        value.each_with_index.map do |entry, index|
+          typed(entry, node.type, node.module_name, Core.pointer(pointer, index), Core.pointer(location, index))
+        end
+
+      when "anydata"
+        unless value.is_a?(Hash)
+          invalid(pointer, "anydata must be an object", "structure")
+          return value
+        end
+        anydata_object(value, pointer, location)
+      when "anyxml"
+        opaque(value, pointer, anydata: false)
+        value
+      end
+    end
+
+    def typed(value, type, module_name, pointer, location)
+      Types.convert(value, type, mode: @mode, module_name: module_name, schema: @schema, limits: @limits,
+                                 pointer: location, selections: @selections)
+    rescue ConversionError => e
+      invalid(pointer, e.message, "type")
+      value
+    end
+
+    def annotations(value, pointer, location)
+      unless value.is_a?(Hash)
+        invalid(pointer, "Metadata object must be an object", "metadata")
+        return value
+      end
+      value.to_h do |name, item|
+        path = Core.pointer(pointer, name)
+        type = @schema.annotations[name]
+        if !Core::NAME.match?(name) || !name.include?(":") || !type
+          invalid(path, "Unknown or unqualified metadata annotation", "metadata")
+          [name, item]
+        else
+          [name, typed(item, type, name.split(":", 2).first, path, Core.pointer(location, name))]
+        end
+      end
+    end
+
+    def wire_name(node, parent)
+      node.module_name == parent ? node.name.split(":", 2).last : node.name
+    end
+
+    # Names and values inside schema-less anydata remain in wire form. Only
+    # registered annotations can be assigned native types without a content schema.
+    def anydata_object(value, pointer, location)
+      value.to_h do |name, item|
+        path = Core.pointer(pointer, name)
+        position = Core.pointer(location, name)
+        if name == "@"
+          [name, annotations(item, path, position)]
+        elsif name.start_with?("@")
+          sibling = value[name.delete_prefix("@")]
+          invalid(path, "Metadata must accompany a scalar or leaf-list", "metadata") unless value.key?(name.delete_prefix("@")) && !sibling.is_a?(Hash)
+          if sibling.is_a?(Array) && sibling != [nil]
+            if item.is_a?(Array) && item.length <= sibling.length && sibling.none?(Hash)
+              [name, item.each_with_index.map { |entry, i| entry.nil? ? nil : annotations(entry, Core.pointer(path, i), Core.pointer(position, i)) }]
+            else
+              invalid(path, "Leaf-list metadata must align with its values", "metadata")
+              [name, item]
+            end
+          else
+            [name, annotations(item, path, position)]
+          end
+        else
+          invalid(path, "Invalid anydata member name", "anydata") unless Core::NAME.match?(name)
+          if item.is_a?(Hash)
+            [name, anydata_object(item, path, position)]
+          elsif item.is_a?(Array) && item.all?(Hash)
+            [name, item.each_with_index.map { |entry, i| anydata_object(entry, Core.pointer(path, i), Core.pointer(position, i)) }]
+          else
+            opaque(item, path, anydata: true)
+            [name, item]
+          end
+        end
+      end
+    end
+
+    def opaque(value, pointer, anydata:)
+      case value
+      when Hash
+        value.each do |name, item|
+          invalid(Core.pointer(pointer, name), "Invalid anydata member name", "anydata") if anydata && !Core::NAME.match?(name)
+          opaque(item, Core.pointer(pointer, name), anydata: anydata)
+        end
+      when Array
+        if anydata
+          return if value == [nil]
+
+          objects = value.all?(Hash)
+          scalars = value.all? { |entry| entry == [nil] || !(entry.is_a?(Hash) || entry.is_a?(Array) || entry.nil?) }
+          unless objects || (scalars && value.uniq.length == value.length)
+            invalid(pointer, "anydata array must contain objects or unique scalar values", "anydata")
+          end
+        end
+        value.each_with_index { |item, index| opaque(item, Core.pointer(pointer, index), anydata: anydata) }
+      when NilClass
+        invalid(pointer, "anydata null is only valid as [null]", "anydata") if anydata
+      when Integer
+        invalid(pointer, "Opaque JSON integer exceeds the interoperable range", "i-json") if value.abs > ((2**53) - 1)
+      when BigDecimal
+        invalid(pointer, "Opaque JSON cannot contain native decimal values", "i-json")
+      when String
+        invalid(pointer, "Opaque JSON requires Unicode strings", "i-json") unless Core.string(value)
+      end
+    end
+  end
+end

data/lib/yang_json/types.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+module YangJSON
+  module Types
+    PRIMITIVES = %w[int8 int16 int32 int64 uint8 uint16 uint32 uint64 string enumeration boolean bits binary identityref empty
+                    instance-identifier].each(&:freeze).freeze
+    INTEGER_TYPES = %w[int8 int16 int32 int64 uint8 uint16 uint32 uint64].each(&:freeze).freeze
+
+    module_function
+
+    def convert(value, type, mode:, module_name:, schema:, limits:, pointer:, selections:)
+      name, parameter = type.is_a?(Array) ? type : [type, nil]
+      if name == "union"
+        indices = (0...parameter.length).to_a
+        preferred = selections[pointer] if mode == :encode
+        indices = [preferred] + (indices - [preferred]) if preferred && indices.include?(preferred)
+        indices.each do |index|
+          result = convert(value, parameter[index], mode: mode, module_name: module_name, schema: schema, limits: limits,
+                                                    pointer: "#{pointer}/union#{index}", selections: selections)
+          selections[pointer] = index if mode == :decode
+          return result
+        rescue ConversionError
+          next
+        end
+        raise ConversionError, "Value does not match any union member"
+      end
+      case name
+      when *INTEGER_TYPES then integer(value, name, mode)
+      when "decimal64" then decimal(value, parameter, mode)
+      when "string", "enumeration"
+        raise ConversionError, "Expected a Unicode string" unless Core.string(value)
+
+        value.dup
+      when "boolean"
+        raise ConversionError, "Expected a boolean" unless [true, false].include?(value)
+
+        value
+      when "empty"
+        expected = mode == :decode ? [nil] : true
+        raise ConversionError, "Invalid empty value" unless value == expected
+
+        mode == :decode ? true : [nil]
+      when "bits" then bits(value, mode)
+      when "binary" then binary(value, mode, limits[:max_binary_bytes])
+      when "identityref" then identity(value, mode, module_name, schema)
+      when "instance-identifier"
+        instance_identifier(value, schema)
+        value.dup
+      else raise ConversionError, "Unsupported data type"
+      end
+    end
+
+    def integer(value, type, mode)
+      bits = type.delete_prefix("u").delete_prefix("int").to_i
+      if mode == :decode && bits == 64
+        raise ConversionError, "64-bit integer must be a decimal string" unless value.is_a?(String) && value.match?(/\A[+-]?[0-9]+\z/)
+        raise ConversionError, "Integer representation is too long" if value.length > 128
+
+        number = Integer(value, 10)
+      else
+        raise ConversionError, "Expected an integer" unless value.is_a?(Integer)
+
+        number = value
+      end
+      range = type.start_with?("u") ? (0..((2**bits) - 1)) : (-(2**(bits - 1))..((2**(bits - 1)) - 1))
+      raise ConversionError, "Integer is out of range" unless range.cover?(number)
+
+      mode == :encode && bits == 64 ? number.to_s : number
+    end
+
+    def decimal(value, digits, mode)
+      if mode == :decode
+        unless value.is_a?(String) && value.length <= 128 && value.match?(/\A[+-]?[0-9]+(?:\.[0-9]+)?\z/)
+          raise ConversionError, "decimal64 must be a decimal string"
+        end
+
+        number = BigDecimal(value)
+      else
+        raise ConversionError, "decimal64 requires BigDecimal" unless value.is_a?(BigDecimal) && value.finite?
+
+        number = value
+      end
+      scaled = number * (10**digits)
+      raise ConversionError, "decimal64 precision or range exceeded" unless scaled.frac.zero? && scaled >= -(2**63) && scaled <= (2**63) - 1
+
+      if mode == :decode
+        number
+      else
+        (number.zero? ? "0.0" : number.to_s("F"))
+      end
+    end
+
+    def bits(value, mode)
+      if mode == :decode
+        raise ConversionError, "bits requires a string" unless value.is_a?(String)
+
+        names = value.split(/[ \t\r\n]+/).reject(&:empty?)
+      else
+        raise ConversionError, "bits requires an array" unless value.is_a?(Array)
+
+        names = value
+      end
+      unless names.all? { |name| name.is_a?(String) && Core::IDENTIFIER.match?(name) } && names.uniq == names
+        raise ConversionError, "Invalid or duplicate bit name"
+      end
+
+      mode == :decode ? names : names.join(" ")
+    end
+
+    def binary(value, mode, limit)
+      raise ConversionError, "binary requires a string" unless value.is_a?(String)
+
+      if mode == :decode
+        raise ConversionError, "Decoded binary limit exceeded" if value.bytesize > ((limit + 2) / 3) * 4
+
+        bytes = Base64.strict_decode64(value)
+        raise ConversionError, "Noncanonical base64 value" unless Base64.strict_encode64(bytes) == value
+      else
+        raise ConversionError, "binary requires an ASCII-8BIT string" unless value.encoding == Encoding::ASCII_8BIT
+
+        bytes = value
+      end
+      raise ConversionError, "Binary byte limit exceeded" if bytes.bytesize > limit
+
+      mode == :decode ? bytes : Base64.strict_encode64(bytes)
+    rescue ArgumentError
+      raise ConversionError, "Invalid base64 value", cause: nil
+    end
+
+    def identity(value, mode, parent, schema)
+      raise ConversionError, "Invalid identity name" unless value.is_a?(String) && Core::NAME.match?(value)
+      raise ConversionError, "Ruby identity must be module-qualified" if mode == :encode && !value.include?(":")
+
+      full = value.include?(":") ? value : "#{parent}:#{value}"
+      module_name, name = full.split(":", 2)
+      raise ConversionError, "Unknown identity module" unless schema.modules.key?(module_name)
+
+      if mode == :decode
+        full
+      else
+        (module_name == parent ? name : full)
+      end
+    end
+
+    def instance_identifier(value, schema)
+      raise ConversionError, "instance-identifier must be an absolute path" unless Core.string(value) && value.start_with?("/")
+
+      offset = 0
+      parent = nil
+      while offset < value.length
+        match = %r{\G/((?:[A-Za-z_][A-Za-z0-9_.-]*:)?[A-Za-z_][A-Za-z0-9_.-]*)}.match(value, offset)
+        raise ConversionError, "Invalid instance-identifier step" unless match
+
+        name = match[1]
+        module_name = name.include?(":") ? name.split(":", 2).first : parent
+        unless module_name && schema.modules.key?(module_name) && (name.include?(":") == (module_name != parent))
+          raise ConversionError, "Invalid instance-identifier namespace"
+        end
+
+        parent = module_name
+        offset = match.end(0)
+        predicate_kind = nil
+        while value[offset] == "["
+          predicate = /\G\[[ \t]*(?:(?:((?:[A-Za-z_][A-Za-z0-9_.-]*:)?[A-Za-z_][A-Za-z0-9_.-]*|\.)[ \t]*=[ \t]*(?:'[^']*'|"[^"]*"))|[1-9][0-9]*)[ \t]*\]/.match(
+            value, offset
+          )
+          raise ConversionError, "Invalid instance-identifier predicate" unless predicate
+
+          key = predicate[1]
+          kind = key && key != "." ? :key : :single
+          raise ConversionError, "Incompatible instance-identifier predicates" if predicate_kind && (predicate_kind != :key || kind != :key)
+
+          predicate_kind = kind
+          if key && key != "." && key.include?(":")
+            module_name = key.split(":", 2).first
+            raise ConversionError, "Invalid predicate namespace" if module_name == parent || !schema.modules.key?(module_name)
+          end
+          offset = predicate.end(0)
+        end
+      end
+    end
+  end
+end

data/lib/yang_json/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module YangJSON
+  VERSION = "0.1.0"
+end
+YangJson = YangJSON

data/lib/yang_json.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative "yang_json/version"
+require_relative "yang_json/core"
+require_relative "yang_json/types"
+require_relative "yang_json/schema"
+require_relative "yang_json/transformer"
+
+module YangJSON
+  # Decode RFC 7951 JSON to module-qualified Ruby values.
+  # @param source [String] UTF-8 JSON text
+  # @param schema [Schema] immutable caller-defined schema
+  # @param strict [Boolean] whether semantic violations raise an exception
+  # @return [Document] converted data, diagnostics and union selections
+  # @raise [ParseError] malformed JSON or a resource limit violation
+  # @raise [ValidationError] a type or structure violation in strict mode
+  def self.decode(source, schema, strict: true, **options)
+    limits = Core.limits(options)
+    value = Core.parse(source, limits)
+    transformer = Transformer.new(schema, mode: :decode, limits: limits)
+    result = transformer.transform(value)
+    raise ValidationError, transformer.violations if strict && !transformer.violations.empty?
+    raise ValidationError, transformer.violations unless result.is_a?(Hash)
+
+    Document.new(result, warnings: transformer.violations, union_members: transformer.selections)
+  end
+
+  # Encode native values; all validation failures are errors.
+  # @param data [Hash] native values with module-qualified modeled keys
+  # @param schema [Schema] immutable caller-defined schema
+  # @return [String] RFC 7951 JSON
+  # @raise [ValidationError] data cannot be represented by the schema
+  def self.encode(data, schema, **options)
+    limits = Core.limits(options)
+    value = Core.copy(data, limits, native: true)
+    selections = data.is_a?(Document) ? data.union_members : {}
+    transformer = Transformer.new(schema, mode: :encode, limits: limits, selections: selections)
+    result = transformer.transform(value)
+    raise ValidationError, transformer.violations unless transformer.violations.empty?
+
+    result = Core.copy(result, limits)
+    encoded = JSON.generate(Core.precise(result), allow_nan: false, max_nesting: limits[:max_depth])
+    raise ConversionError, "Output byte limit exceeded" if encoded.bytesize > limits[:max_bytes]
+
+    encoded
+  rescue JSON::GeneratorError
+    raise ConversionError, "Invalid JSON output", cause: nil
+  end
+
+  # @return [Array<Violation>] all diagnostics, including parse failures
+  def self.validate(source, schema, **)
+    decode(source, schema, strict: false, **).warnings
+  rescue ParseError => e
+    [Violation.new(pointer: "", message: e.message, rule: "parse")]
+  rescue ValidationError => e
+    e.violations
+  end
+
+  def self.parse(source, schema:, **)
+    decode(source, schema, **)
+  end
+end

data/sig/yang_json.rbs

@@ -0,0 +1,53 @@
+module YangJSON
+  VERSION: String
+  type json = nil | bool | Integer | Float | String | Array[json] | Hash[String, json]
+  type value = json | BigDecimal | Array[value] | Hash[String, value]
+  type limits = { ?max_bytes: Integer, ?max_depth: Integer, ?max_nodes: Integer, ?max_items: Integer, ?max_binary_bytes: Integer }
+  type yang_type = String | Array[untyped]
+
+  class Error < StandardError
+  end
+  class ParseError < Error
+  end
+  class ConversionError < Error
+  end
+  class Violation < Data
+    attr_reader pointer: String
+    attr_reader message: String
+    attr_reader rule: String
+    def self.new: (pointer: String, message: String, rule: String) -> instance
+  end
+  class ValidationError < Error
+    attr_reader violations: Array[Violation]
+    attr_reader pointer: String
+    def initialize: (Array[Violation]) -> void
+  end
+  class Document < Hash[String, value]
+    attr_reader warnings: Array[Violation]
+    attr_reader union_members: Hash[String, Integer]
+    def initialize: (Hash[String, value], warnings: Array[Violation], ?union_members: Hash[String, Integer]) -> void
+  end
+  class Node
+    attr_reader name: String
+    attr_reader module_name: String
+    attr_reader kind: String
+    attr_reader type: yang_type?
+    attr_reader children: Hash[String, Node]
+    attr_reader keys: Array[String]
+    def initialize: (name: String, kind: String, ?type: yang_type?, ?children: Hash[String, Node], ?keys: Array[String]) -> void
+  end
+  class Schema
+    attr_reader modules: Hash[String, Array[String]]
+    attr_reader tree: Hash[String, Node]
+    attr_reader annotations: Hash[String, yang_type]
+    def self.from_json: (String, **Integer) -> instance
+    def self.from_jtox: (String, **Integer) -> instance
+    def initialize: (Hash[String, untyped], ?limits: limits) -> void
+    def lookup: (String | Array[String]) -> Node?
+  end
+  def self.decode: (String, Schema, ?strict: bool, **Integer) -> Document
+  def self.parse: (String, schema: Schema, ?strict: bool, **Integer) -> Document
+  def self.encode: (Hash[String, value], Schema, **Integer) -> String
+  def self.validate: (String, Schema, **Integer) -> Array[Violation]
+end
+module YangJson = YangJSON

metadata

@@ -0,0 +1,118 @@
+--- !ruby/object:Gem::Specification
+name: yang_json
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Yudai Takada
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: base64
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1'
+- !ruby/object:Gem::Dependency
+  name: bigdecimal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.19.4
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.19.4
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4'
+description: Schema-aware YANG JSON value conversion, namespace normalization, structural
+  validation, and RFC 7952 annotations.
+email:
+- t.yudai92@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- SECURITY.md
+- data/encoding.yml
+- lib/yang_json.rb
+- lib/yang_json/core.rb
+- lib/yang_json/schema.rb
+- lib/yang_json/transformer.rb
+- lib/yang_json/types.rb
+- lib/yang_json/version.rb
+- sig/yang_json.rbs
+homepage: https://github.com/ydah/yang_json
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/ydah/yang_json
+  source_code_uri: https://github.com/ydah/yang_json/tree/main
+  changelog_uri: https://github.com/ydah/yang_json/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.16
+specification_version: 4
+summary: Read and write RFC 7951 YANG JSON using caller-defined schemas
+test_files: []