ynl 0.1.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b6a0856ea9a2918cc0a1dee7d9452227091209776df336059a4eae4ca85b903e
-  data.tar.gz: 4513210c607ad814734cc0ed03f5e57ed1853da3b86539015a933db6364c5205
+  metadata.gz: c66f9efc470db2a2d772016be6b06574e3551800fae411e2d0b80916d416481d
+  data.tar.gz: e204be8969be35b673a2257bc4d208c764a637e7e38d1e05bb22d7a1ea414132
 SHA512:
-  metadata.gz: ba1fd6ff654ad9c613e98ddcbdf9e28e3b9b24eac873f5e1c19aa2cfa919e2020bc9c7557691d235554f72cc279f89e4612027aef1feaeda43c3d9a98201f76d
-  data.tar.gz: 39ca59b427aa8d8c945350a351518063407583e7e511acf0e4ed5ba901b860dbab65b32daaf0a1218ccdbf7fddd6d0a5c826761f80393f88b361159a8fee4be9
+  metadata.gz: ba3b3866bb1d8aa066f5ab16438540ea1b5a505e8e489065df52388a3551b7333d1d58bfe66fc4d7a315dc78319511487f38367d323cbdf4db8a19333d1feb73
+  data.tar.gz: 3e57557c4fecb51d981099cde028caf80ad98928099428f4e6efff86be0be72e407a52f42d2e9a8fbf1f07e800053675b769eadcd2e9815901b4d937dd858770

data/CHANGELOG.md

@@ -0,0 +1,11 @@
+# ChangeLog
+
+## Unreleased
+
+## v0.2.1 (2026-03-02)
+
+## v0.2.0 (2026-03-02)
+
+## v0.1.0 (2025-04-20)
+
+- Initial release

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 Kasumi Hanazuki
+
+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,3 @@
+# ynl
+
+YNL (YAML Netlink Specification) parser and code generator.

data/Rakefile

@@ -1,4 +1,3 @@
-require 'bundler/gem_tasks'
 require 'rspec/core/rake_task'
 
 RSpec::Core::RakeTask.new(:spec)

data/lib/ynl/family.rb

@@ -5,16 +5,18 @@ require_relative 'generator'
 
 module Ynl
   class Family
+    # Builds a Ruby class from a spec file
     def self.build(path)
-      require 'nl'
-
-      defs = Ynl::Parser.parse_file(path)
-
       buf = StringIO.new
-      classname = Generator.new(defs, buf).generate(namespace: 'self')
-      classdef = buf.string
+      classname = File.open(path) {|f| generate(f, buf, namespace: 'self') }
+
+      Module.new { eval(buf.string) }.const_get(classname)
+    end
 
-      Module.new { eval(classdef) }.const_get(classname)
+    # Generates Ruby code from a spec source
+    def self.generate(source, out, **kwargs)
+      out << Generator::PRELUDE
+      Generator.new(Ynl::Parser.new(source).parse, out).generate(**kwargs)
     end
   end
 end

data/lib/ynl/generator.rb

@@ -5,15 +5,15 @@ module Ynl
 
       refine(String) do
         def as_const_name
-          split(WORD_DELIM).map(&:upcase).join('_')
+          split(WORD_DELIM).map(&:upcase).join('_').tap {|s| s.prepend('X_') unless s.start_with?(/[A-Z]/i) }
         end
 
         def as_class_name
-          split(WORD_DELIM).map(&:capitalize).join
+          split(WORD_DELIM).map(&:capitalize).join.tap {|s| s.prepend('X') unless s.start_with?(/[A-Z]/i) }
         end
 
         def as_variable_name
-          split(WORD_DELIM).join('_')
+          split(WORD_DELIM).join('_').tap {|s| s.prepend('x_') unless s.start_with?(/[A-Z]/i) }
         end
         alias as_method_name as_variable_name
 
@@ -26,10 +26,17 @@ module Ynl
         end
       end
     end
-    private_constant :Refinements
+    # private_constant :Refinements
 
     using Refinements
 
+    PRELUDE = -<<~RUBY
+      # frozen_string_literal: true
+      # rbs_inline: enabled
+      # This code is generated by Ynl::Generator. DO NOT EDIT.
+      require 'nl'
+    RUBY
+
     def initialize(ynl, out)
       @ynl = ynl
       @out = out
@@ -37,29 +44,54 @@ module Ynl
     end
 
     def generate(superclass: '::Nl::Family', namespace: nil)
+      @protocol = '::Nl::Protocols::' + (@ynl.protocol == 'netlink-raw' ? 'Raw' : 'Genl')
+
+      emit_comment(@ynl.doc)
+
       classname = @ynl.name.as_class_name
       emit_class([*namespace, classname].join('::'), superclass) do
-        write('NAME = ', @ynl.name.as_string_literal)
-        write('PROTONUM = ', @ynl.protonum)
+        emit_const('NAME', @ynl.name.as_string_literal)
 
         if @ynl.protocol == 'netlink-raw'
-          write('PROTOCOL = Ractor.make_shareable(::Nl::Protocols::Raw.new(', @ynl.name.as_string_literal, ', ', @ynl.protonum ,'))')
+          emit_const('PROTOCOL', "Ractor.make_shareable(::Nl::Protocols::Raw.new(#{@ynl.name.as_string_literal}, #{@ynl.protonum}))")
         else
-          write('PROTOCOL = Ractor.make_shareable(::Nl::Protocols::Genl.new(', @ynl.name.as_string_literal, ')')
+          emit_const('PROTOCOL', "Ractor.make_shareable(::Nl::Protocols::Genl.new(#{@ynl.name.as_string_literal}))")
         end
 
         emit_module('Structs') do
           @ynl.structs.each do |name, struct|
             emit_comment(struct.doc)
-            write(name.as_class_name, ' = Struct.new(', struct.members.map { it.name.as_variable_name.as_symbol_literal }.join(', ') ,')')
+            write(name.as_class_name, " = Struct.new(")
+            indent do
+              struct.members.each do |member|
+                write(member.name.as_variable_name.as_symbol_literal, ', #: ', member.type.rbs_type)
+              end
+            end
+            write(')')
             emit_class(name.as_class_name) do
-              write('MEMBERS = Ractor.make_shareable({', struct.members.map { "#{it.name.as_variable_name}: #{to_datatype(it.type, nil)}" }.join(', ') ,'})')
+              emit_nodoc
+              emit_const(
+                'MEMBERS',
+                "Ractor.make_shareable({#{struct.members.map { "#{it.name.as_variable_name}: #{to_datatype(it.type, nil)}" }.join(', ') }})",
+                rbs: 'Hash[::Symbol, ::Nl::_DataType]',
+              )
+
+              emit_comment('Decodes the struct.')
+              emit_rbs_comment(
+                'decoder: ::Nl::Decoder',
+                'return: instance',
+              )
               write('def self.decode(decoder)')
               indent do
                 write('self.new(*MEMBERS.map {|name, datatype| datatype.decode(decoder) })')
               end
               write('end')
 
+              emit_comment('Encodes the struct.')
+              emit_rbs_comment(
+                'encoder: ::Nl::Encoder',
+                'return: void',
+              )
               write('def encode(encoder)')
               indent do
                 write('MEMBERS.each {|name, datatype| datatype.encode(encoder, self.public_send(name)) }')
@@ -70,56 +102,106 @@ module Ynl
         end
 
         emit_module('AttributeSets') do
+          deferred_consts = []
           @ynl.attribute_sets.each do |name, attr_set|
             emit_comment(attr_set.doc)
-            emit_class(name.as_class_name, '::Nl::Family::AttributeSet') do
+            emit_class(name.as_class_name, @protocol + '::AttributeSet') do
               emit_comment("Abstract class")
-              emit_class('Attribute', '::Nl::Family::AttributeSet::Attribute') do
+              emit_class('Attribute', @protocol + '::AttributeSet::Attribute') do
               end
               attr_set.attributes.each do |attr|
                 emit_comment(attr.doc)
                 emit_class(attr.name.as_class_name, 'Attribute') do
-                  write('TYPE = ', attr.value)
-                  write('NAME =', attr.name.as_variable_name.as_symbol_literal)
-                  write('DATATYPE = ', to_datatype(attr.type, attr.checks))
+                  emit_const('TYPE', attr.value)
+                  emit_const('NAME', attr.name.as_variable_name.as_symbol_literal)
+                  if attr.type.is_a?(Types::NestedAttributes) ||
+                    (attr.type.is_a?(Types::IndexedArray) && attr.type.sub_type.is_a?(Types::NestedAttributes))
+                    deferred_consts << ["#{name.as_class_name}::#{attr.name.as_class_name}::DATATYPE", to_datatype(attr.type, attr.checks)]
+                  else
+                    emit_const('DATATYPE', to_datatype(attr.type, attr.checks))
+                  end
                 end
               end
 
-              write('BY_NAME = Ractor.make_shareable({', attr_set.attributes.map { "#{it.name.as_variable_name.as_symbol_literal} => #{it.name.as_class_name}" }.join(', ') ,'})')
-              write('BY_TYPE = Ractor.make_shareable({', attr_set.attributes.map { "#{it.value} => #{it.name.as_class_name}" }.join(', ') ,'})')
+              emit_nodoc
+              emit_const(
+                'BY_NAME',
+                "Ractor.make_shareable({#{attr_set.attributes.map { "#{it.name.as_variable_name.as_symbol_literal} => #{it.name.as_class_name}" }.join(', ') }})",
+                rbs: 'Hash[::Symbol, Attribute]',
+              )
+
+              emit_nodoc
+              emit_const(
+                'BY_TYPE',
+                "Ractor.make_shareable({#{attr_set.attributes.map { "#{it.value} => #{it.name.as_class_name}" }.join(', ') }})",
+                rbs: 'Hash[::Integer, Attribute]',
+              )
 
               emit_singleton_class do
+                emit_comment('Looks up Attribute class by name.')
                 emit_rbs_comment(
                   'name: Symbol',
                   'return: Attribute',
                 )
-                write('def by_name(name) = BY_NAME[name]')
+                emit_getter('by_name(name)', 'BY_NAME.fetch(name)')
 
+                emit_comment('Looks up Attribute class by type value.')
                 emit_rbs_comment(
                   'type: Integer',
                   'return: Attribute',
                 )
-                write('def by_type(type) = BY_TYPE[type]')
+                emit_getter('by_type(type)', 'BY_TYPE.fetch(type)')
               end
             end
           end
+          deferred_consts.each { emit_const(*it) }
         end
 
         emit_module('Messages') do
           @ynl.operations.each do |name, oper|
-            emit_comment(oper.doc)
             %w[do dump].each do |method|
               if request_reply = oper.public_send(method + 'it')
                 %w[request reply].to_h { [it, request_reply.public_send(it)] }.compact.each do |type, msg|
-                  emit_class(method.as_class_name + oper.name.as_class_name + type.as_class_name, '::Nl::Family::Message') do
-                    write('TYPE = ', msg.value)
-                    write('FIXED_HEADER = ', oper.fixed_header&.then { 'Structs::' + it.name.as_class_name } || 'nil')
-                    write('ATTRIBUTE_SET = AttributeSets::', oper.attribute_set.name.as_class_name)
+                  emit_comment(oper.doc)
+                  emit_class(method.as_class_name + oper.name.as_class_name + type.as_class_name, "#{@protocol}::Message") do
+                    emit_const('TYPE', msg.value)
+                    emit_const('FIXED_HEADER', oper.fixed_header&.then { 'Structs::' + it.name.as_class_name } || 'nil')
+                    emit_const('ATTRIBUTE_SET', "AttributeSets::#{oper.attribute_set.name.as_class_name}")
                     params = msg.attributes
-                    header_params = params & (oper.fixed_header&.members&.map(&:name) || [])
-                    attribute_params = params & (oper.attribute_set.attributes.map(&:name))
-                    write('HEADER_PARAMS = Ractor.make_shareable(%i[', header_params.map { it.as_variable_name }.join(' ') ,'])')
-                    write('ATTRIBUTE_PARAMS = Ractor.make_shareable(%i[', attribute_params.map { it.as_variable_name }.join(' ') ,'])')
+                    attribute_params = oper.attribute_set.attributes.map(&:name) & params
+                    emit_const('ATTRIBUTES', "Ractor.make_shareable(%i[#{attribute_params.map { it.as_variable_name }.join(' ')}])")
+                    oper.fixed_header.members.each do |member|
+                      param = member.name
+                      datatype = member.type
+                      next if datatype.is_a? Types::Pad
+                      next if attribute_params.include?(param)
+                      emit_comment("Gets the value of `#{param}` field in the message's fixed header.")
+                      emit_rbs_comment(
+                        'return: ' + datatype.rbs_type,
+                      )
+                      emit_getter(param.as_method_name, "fixed_header.#{param.as_method_name}")
+                    end if oper.fixed_header
+                    attribute_params.each do |param|
+                      datatype = oper.attribute_set.attributes.find { it.name == param }.type
+                      next if datatype.is_a? Types::Pad
+                      extending = oper.fixed_header&.members&.any? { it.name == param }
+
+                      if extending
+                        emit_comment("Gets the value of `#{param}` attribute or fixed header in the message.")
+                      else
+                        emit_comment("Gets the value of `#{param}` attribute in the message.")
+                      end
+                      emit_rbs_comment(
+                        'return: ' + datatype.rbs_type,
+                      )
+                      if extending
+                        # If the fixed header and the attribute set have the same-name parameter, the value from the attribute should have
+                        # the precedence over that from the header.
+                        emit_getter(param.as_method_name, "attributes[#{param.as_variable_name.as_symbol_literal}]&.value || fixed_header.#{param.as_method_name}")
+                      else
+                        emit_getter(param.as_method_name, "attributes[#{param.as_variable_name.as_symbol_literal}]&.value")
+                      end
+                    end
                   end
                 end
               end
@@ -131,16 +213,37 @@ module Ynl
         @ynl.operations.each do |name, oper|
           %w[do dump].each do |method|
             if request_reply = oper.public_send(method + 'it')
+              next unless request = request_reply.request  # FIXME: what should we do in this case?
+
+              request_class = "Messages::#{method.as_class_name}#{oper.name.as_class_name}Request"
+              reply_class = request_reply.reply ? "Messages::#{method.as_class_name}#{oper.name.as_class_name}Reply" : 'nil'
+
+              header_params = oper.fixed_header&.members || []
+              attribute_params = oper.attribute_set.attributes.filter { request.attributes.include?(it.name) }
+              attribute_params.reject! {|a| header_params.any? {|h| h.name == a.name  } }  # The two params should have the same Ruby type anyway
+              params = header_params + attribute_params
+              params.reject! { it.type.is_a? Types::Pad }
+
+              rbs_params = params.map { |it| "?#{it.name.as_variable_name}: #{it.type.rbs_type}" }.join(', ')
+              rbs_result = request_reply.reply ? reply_class : 'void'
+
               emit_comment(oper.doc)
-              write('def ', method.as_method_name, '_', oper.name.as_method_name, '(**args)')
-              indent do
-                request_class = "Messages::#{method.as_class_name}#{oper.name.as_class_name}Request"
-                if request_reply.reply
-                  reply_class = "Messages::#{method.as_class_name}#{oper.name.as_class_name}Reply"
-                else
-                  reply_class = 'nil'
+              if method == 'dump'
+                emit_rbs_comment(
+                  "(#{rbs_params}) -> Enumerable[#{rbs_result}]\n  | (#{rbs_params}) { (#{rbs_result}) -> void } -> void",
+                )
+                write("def #{method.as_method_name}_#{oper.name.as_method_name}(**args, &block)")
+                indent do
+                  write("exchange_message(#{method.as_symbol_literal}, #{request_class}, #{reply_class}, args, &block)")
+                end
+              else
+                emit_rbs_comment(
+                  "(#{rbs_params}) -> #{rbs_result}",
+                )
+                write("def #{method.as_method_name}_#{oper.name.as_method_name}(**args)")
+                indent do
+                  write("exchange_message(#{method.as_symbol_literal}, #{request_class}, #{reply_class}, args)")
                 end
-                write("exchange_message(#{method.as_symbol_literal}, #{request_class}, #{reply_class}, args)")
               end
               write('end')
             end
@@ -188,35 +291,56 @@ module Ynl
       write('end')
     end
 
+    private def emit_const(name, value, rbs: nil)
+      write(name, ' = ', value, *([' #: ', rbs] if rbs))
+    end
+
+    private def emit_getter(name, expr)
+      write('def ', name, '; ', expr, '; end')
+    end
+
+    private def emit_nodoc
+      write('# :nodoc:')
+    end
+
     private def emit_comment(comment)
       return unless comment
-      comment.each_line do |line|
+      comment.each_line(chomp: true) do |line|
         write('# ', line)
       end
     end
 
     private def emit_rbs_comment(*args)
+      write('#--')
       args.each do |arg|
-        write('# @rbs ', arg)
+        emit_comment('@rbs ' + arg)
       end
     end
 
     private def to_datatype(type, checks)
       case type
       when Types::Pad
-        'nil'
+        "#{@protocol}::DataTypes::Pad.new(#{type.length})"
+      when Types::Flag
+        "#{@protocol}::DataTypes::Flag.new"
+      when Types::Bitfield32
+        "#{@protocol}::DataTypes::Bitfield32.new"
       when Types::Scalar
-        "PROTOCOL.class::DataTypes::Scalar.new(::Nl::Endian::#{type.byte_order.name.as_class_name}::#{type.type.as_class_name}, check: #{to_checks(checks)})"
+        "#{@protocol}::DataTypes::Scalar.new(::Nl::Endian::#{type.byte_order.name.as_class_name}::#{type.type.as_const_name}, check: #{to_checks(checks)})"
       when Types::String
-        "PROTOCOL.class::DataTypes::String.new(check: #{to_checks(checks)})"
+        "#{@protocol}::DataTypes::String.new(check: #{to_checks(checks)})"
       when Types::Binary
         # if type.struct
         #   "Structs::" + type.struct.name.as_class_name
         # else
-        "PROTOCOL.class::DataTypes::Binary.new(check: #{to_checks(checks)})"
+        "#{@protocol}::DataTypes::Binary.new(check: #{to_checks(checks)})"
         # end
       when Types::NestedAttributes
-        "PROTOCOL.class::DataTypes::NestedAttributes.new(#{type.attribute_set.name.as_class_name})"
+        "#{@protocol}::DataTypes::NestedAttributes.new(#{type.attribute_set.name.as_class_name})"
+      when Types::IndexedArray
+        "#{@protocol}::DataTypes::IndexedArray.new(#{to_datatype(type.sub_type, nil)})"
+      when Types::SubMessage
+        "#{@protocol}::DataTypes::Binary.new(check: nil)"
       else
         raise "Unknown type: #{type.class}"
       end

data/lib/ynl/models.rb

@@ -27,6 +27,23 @@ module Ynl
       end
     end
 
+    Const = ::Struct.new(:name, :value, :doc)
+
+    class SubMessage
+      Format = ::Struct.new(:value, :attribute_set)
+
+      attr_reader :name, :formats
+
+      def initialize(name:)
+        @name = name
+        @formats = []
+      end
+
+      def resolve(f)
+        self
+      end
+    end
+
     class Enum
       Entry = ::Struct.new(:name, :value, :doc)
 
@@ -106,6 +123,31 @@ module Ynl
       end
     end
 
+    class AttributeSubset
+      attr_reader :name, :superset, :doc
+
+      def initialize(name:, superset:, attributes:, doc:)
+        @name = name
+        @superset = superset
+        @attributes = attributes
+        @doc = doc
+      end
+
+      def attributes
+        # WORKAROUND: Some upstream specs (e.g. devlink) contain duplicate attribute
+        # entries in subset-of attribute sets. Deduplicate by name here until the
+        # upstream specs are fixed.
+        @attributes.uniq {|attr| attr.fetch('name') }.map do |attr|
+          name = attr.fetch('name')
+          superset.attributes.find { it.name == name } or raise ParseError "No attribute with name #{name}"
+        end
+      end
+
+      def resolve(f)
+        self
+      end
+    end
+
     class Operation
       attr_reader :name, :doc, :fixed_header, :attribute_set, :doit, :dumpit
 
@@ -119,8 +161,8 @@ module Ynl
       end
 
       def resolve(f)
-        @doit = @doit.resolve(f)
-        @dumpit = @dumpit.resolve(f)
+        @doit = @doit&.resolve(f)
+        @dumpit = @dumpit&.resolve(f)
         self
       end
     end
@@ -134,8 +176,8 @@ module Ynl
       end
 
       def resolve(f)
-        @request = @request.resolve(f)
-        @reply = @reply.resolve(f)
+        @request = @request&.resolve(f)
+        @reply = @reply&.resolve(f)
         self
       end
     end

data/lib/ynl/parser.rb

@@ -26,7 +26,7 @@ module Ynl
       protocol = @yaml['protocol'] || 'genetlink'
       protonum = @yaml['protonum']
       name = @yaml['name']
-      doc = @yaml['doc']
+      doc = translate_doc(@yaml['doc'])
 
       @yaml['definitions']&.each do |d|
         parse_definition(d)
@@ -41,14 +41,42 @@ module Ynl
         enum_model = case operations['enum-model']
         when 'directional'
           :directional
-        when nil
-          :unidirectional
+        when 'unified', nil
+          :unified
         else
           raise ParseError, "Unknown enum model: #{operations['enum-model']}"
         end
         @default_fixed_header = operations['fixed-header']&.then { @structs.fetch(it) }
-        operations['list']&.each do |d|
-          parse_operation(d, enum_model:)
+
+        if enum_model == :unified
+          counter = 0
+          operations['list']&.each do |d|
+            counter = d['value'] || (counter + 1)
+            parse_operation(d, request_id: counter, reply_id: counter)
+          end
+        else
+          request_counter = 1
+          reply_counter = 1
+          operations['list']&.each do |d|
+            if d.key?('notify') || d.key?('event')
+              reply_counter = d['value'] || reply_counter
+              parse_operation(d, request_id: nil, reply_id: reply_counter)
+              reply_counter += 1
+            else
+              primary = d['do'] || d['dump']
+              request_counter = primary&.dig('request', 'value') || request_counter
+              request_id = request_counter
+              request_counter += 1
+              if primary&.key?('reply')
+                reply_counter = primary.dig('reply', 'value') || reply_counter
+                reply_id = reply_counter
+                reply_counter += 1
+              else
+                reply_id = nil
+              end
+              parse_operation(d, request_id:, reply_id:)
+            end
+          end
         end
       end
       @yaml['mcast-groups']&.each do |d|
@@ -90,9 +118,14 @@ module Ynl
       end
     end
 
+    private def parse_const(d)
+      name = "#{d['name-prefix']}#{d.fetch('name')}"
+      Models::Const.new(name, d.fetch('value'), translate_doc(d['doc']))
+    end
+
     private def parse_enum_flags(d, type:)
       cls = type == :enum ? Models::Enum : Models::Flags
-      result = cls.new(name: d.fetch('name'), doc: d['doc'])
+      result = cls.new(name: d.fetch('name'), doc: translate_doc(d['doc']))
 
       start_value = d['start-value'] || 0
       value = type == :enum ? start_value : 1 << start_value
@@ -102,7 +135,7 @@ module Ynl
         when String
           entry = cls::Entry.new(name: v, value:)
         when Hash
-          entry = cls::Entry.new(name: v.fetch('name'), value:, doc: v['doc'])
+          entry = cls::Entry.new(name: v.fetch('name'), value:, doc: translate_doc(v['doc']))
         else
           raise ParseError, "Unknown class for enum/flags entry: #{v.class}"
         end
@@ -145,7 +178,7 @@ module Ynl
     private def parse_attribute_type(d)
       type = d.fetch('type')
       case type
-      when 'u8', 'u16', 'u32', 'u64', 's8', 's16', 's32', 's64', 'int', 'uint'
+      when 'u8', 'u16', 'u32', 'u64', 's8', 's16', 's32', 's64', 'int', 'uint', 'sint'
         Types::Scalar.new(
           type: type,
           byte_order: parse_byte_order(d['byte-order']),
@@ -161,6 +194,18 @@ module Ynl
         Types::NestedAttributes.new(
           attribute_set: Models::Thunk.new {|f| f.attribute_sets.fetch(d.fetch('nested-attributes')) },
         )
+      when 'indexed-array'
+        Types::IndexedArray.new(
+          sub_type: parse_indexed_array_sub_type(d),
+        )
+      when 'nest-type-value'
+        if d['nested-attributes']
+          Types::NestedAttributes.new(
+            attribute_set: Models::Thunk.new {|f| f.attribute_sets.fetch(d.fetch('nested-attributes')) },
+          )
+        else
+          Types::Binary.new(struct: nil, display_hint: nil)
+        end
       when 'sub-message'
         Types::SubMessage.new(
           sub_message: Models::Thunk.new {|f| f.sub_messages.fetch(d.fetch('sub-message')) },
@@ -170,6 +215,10 @@ module Ynl
         Types::Pad.new(
           length: nil,
         )
+      when 'flag'
+        Types::Flag.new
+      when 'bitfield32'
+        Types::Bitfield32.new
       when 'unused'
         nil
       else
@@ -177,6 +226,28 @@ module Ynl
       end
     end
 
+    private def parse_indexed_array_sub_type(d)
+      sub_type = d.fetch('sub-type')
+      case sub_type
+      when 'u8', 'u16', 'u32', 'u64', 's8', 's16', 's32', 's64', 'int', 'uint', 'sint'
+        Types::Scalar.new(
+          type: sub_type,
+          byte_order: parse_byte_order(d['byte-order']),
+        )
+      when 'binary'
+        Types::Binary.new(
+          struct: nil,
+          display_hint: d['display-hint'],
+        )
+      when 'nest'
+        Types::NestedAttributes.new(
+          attribute_set: Models::Thunk.new {|f| f.attribute_sets.fetch(d.fetch('nested-attributes')) },
+        )
+      else
+        raise ParseError, "Unknown indexed-array sub-type: #{sub_type}"
+      end
+    end
+
     private def parse_byte_order(v)
       case v
       when nil
@@ -191,11 +262,11 @@ module Ynl
     end
 
     private def parse_struct(d)
-      result = Models::Struct.new(name: d.fetch('name'), doc: d['doc'])
+      result = Models::Struct.new(name: d.fetch('name'), doc: translate_doc(d['doc']))
 
       d.fetch('members').each do |v|
         type = parse_struct_member_type(v)
-        member = Models::Struct::Member.new(name: v.fetch('name'), type: type, doc: v['doc'])
+        member = Models::Struct::Member.new(name: v.fetch('name'), type: type, doc: translate_doc(v['doc']))
         result.members << member
       rescue
         raise ParseError, "Failed to parse struct member: #{v.fetch('name')}"
@@ -207,7 +278,7 @@ module Ynl
     end
 
     private def parse_checks(d)
-      d.map do |op, value|
+      d.filter_map do |op, value|
         parse_check(op, value)
       end
     rescue
@@ -218,16 +289,21 @@ module Ynl
       case op
       when 'max'
         value = parse_value(value_literal)
-        return %{raise unless it <= #{value}}
+        return %{raise ArgumentError, "Value \#{it.inspect} is greater than maximum #{value}" unless it <= #{value}}
       when 'min'
         value = parse_value(value_literal)
-        return %{raise unless it >= #{value}}
+        return %{raise ArgumentError, "Value \#{it.inspect} is less than minimum #{value}" unless it >= #{value}}
       when 'min-len'
         value = parse_value(value_literal)
-        return %{raise unless it.bytesize >= #{value}}
+        return %{raise ArgumentError, "Value \#{it.inspect} is shorter than minimum length #{value}" unless it.bytesize >= #{value}}
       when 'max-len'
         value = parse_value(value_literal)
-        return %{raise unless it.bytesize <= #{value}}
+        return %{raise ArgumentError, "Value \#{it.inspect} is longer than maximum length #{value}" unless it.bytesize <= #{value}}
+      when 'exact-len'
+        value = parse_value(value_literal)
+        return %{raise ArgumentError, "Value \#{it.inspect} is not equal to length #{value}" unless it.bytesize == #{value}}
+      when 'unterminated-ok'
+        return nil
       else
         raise ParseError, "Unknown check: #{op}"
       end
@@ -243,6 +319,9 @@ module Ynl
         (2 ** 32) - 1
       when 's32-max'
         (2 ** 31) - 1
+      when String
+        const = @consts[v] or raise ParseError, "Unknown value: #{v}"
+        const.value
       else
         raise ParseError, "Unknown value: #{v}"
       end
@@ -251,22 +330,11 @@ module Ynl
     private def parse_attribute_set(d)
       name = d.fetch('name')
       if subset_of = d['subset-of']
-        result = Models::Thunk.new do |f|
-          superset = f.attribute_sets.fetch(subset_of)
-          attribute_set = Models::AttributeSet.new(name:, name_prefix: superset.name_prefix, doc: d['doc'])
-          d.fetch('attributes').each do |v|
-            aname = v.fetch('name')
-            sattr = superset.attributes.find {|a| a.name == aname } or raise ParseError, "Attribute not found: #{aname}"
-            # TODO: type/checks overrides
-            attribute_set.attributes << sattr
-          rescue
-            raise ParseError, "Failed to parse attribute: #{v.fetch('name')}"
-          end
-          attribute_set
-        end
+        superset = @attribute_sets.fetch(subset_of)
+        result = Models::AttributeSubset.new(name:, superset:, attributes: d.fetch('attributes'), doc: translate_doc(d['doc']))
       else
         name_prefix = d['name_prefix']
-        result = Models::AttributeSet.new(name:, name_prefix:, doc: d['doc'])
+        result = Models::AttributeSet.new(name:, name_prefix:, doc: translate_doc(d['doc']))
         value = 0
 
         d.fetch('attributes').each do |v|
@@ -290,9 +358,16 @@ module Ynl
     end
 
     private def parse_sub_message(d)
+      name = d.fetch('name')
+      result = Models::SubMessage.new(name:)
+      d.fetch('formats', []).each do |fmt|
+        attr_set = fmt['attribute-set']&.then { @attribute_sets[it] }
+        result.formats << Models::SubMessage::Format.new(fmt['value'], attr_set)
+      end
+      @sub_messages[name] = result
     end
 
-    private def parse_operation(d, enum_model:)
+    private def parse_operation(d, request_id:, reply_id:)
       name = d.fetch('name')
 
       fixed_header = d['fixed-header']&.then do
@@ -307,24 +382,35 @@ module Ynl
         raise ParseError, "Undefined attribute set: #{it}"
       end
 
-      doit = d['do']&.then { parse_request_reply(it) }
-      dumpit = d['dump']&.then { parse_request_reply(it) }
+      doit = d['do']&.then { parse_request_reply(it, default_request_id: request_id, default_reply_id: reply_id) }
+      dumpit = d['dump']&.then { parse_request_reply(it, default_request_id: request_id, default_reply_id: reply_id) }
+
+      # TODO: notify
 
-      @operations[name] = Models::Operation.new(name:, doc: d['doc'], fixed_header:, attribute_set:, doit:, dumpit:)
+      @operations[name] = Models::Operation.new(
+        name:, doc: translate_doc(d['doc']), fixed_header:, attribute_set:,
+        doit:, dumpit:,
+      )
     end
 
-    private def parse_request_reply(d)
+    private def parse_request_reply(d, default_request_id:, default_reply_id:)
       Models::RequestReply.new(
-        request: d['request']&.then { parse_message(it) },
-        reply: d['reply']&.then { parse_message(it) },
+        request: d['request']&.then { parse_message(it, default_id: default_request_id) },
+        reply: d['reply']&.then { parse_message(it, default_id: default_reply_id) },
       )
     end
 
-    private def parse_message(d)
-      Models::Message.new(value: d['value'], attributes: d.fetch('attributes', []))
+    private def parse_message(d, default_id:)
+      Models::Message.new(value: d['value'] || default_id, attributes: d.fetch('attributes', []))
     end
 
     private def parse_mcast_group(d)
     end
+
+    private def translate_doc(doc)
+      return unless doc
+
+      doc.gsub(/(?:\s|^)\K@(?<ident>[\w.-]+)/i) { "`#{$~[:ident]}`" }
+    end
   end
 end

data/lib/ynl/version.rb

@@ -0,0 +1,3 @@
+module Ynl
+  VERSION = '0.2.1'
+end

data/lib/ynl.rb

@@ -12,36 +12,92 @@ module Ynl
       def resolve(f)
         self
       end
+
+      def rbs_type
+        '::Integer'
+      end
     end
     String = Struct.new do
       def resolve(f)
         self
       end
+
+      def rbs_type
+        '::String'
+      end
     end
     Binary = Struct.new(:struct, :length, :display_hint) do
       def resolve(f)
         self.struct = struct.resolve(f) if self.struct
         self
       end
+
+      def rbs_type
+        'untyped'
+      end
     end
     NestedAttributes = Struct.new(:attribute_set) do
+      using Generator::Refinements  # FIXME:
+
       def resolve(f)
         self.attribute_set = attribute_set.resolve(f)
         self
       end
+
+      def rbs_type
+        'AttributeSets::' + attribute_set.name.as_class_name
+      end
     end
     SubMessage = Struct.new(:sub_message, :selector) do
       def resolve(f)
         self.sub_message = sub_message.resolve(f)
         self
       end
+
+      def rbs_type
+        'untyped'
+      end
     end
 
     Pad = Data.define(:length) do
       def resolve(f)
         self
       end
+
+      def rbs_type
+        'nil'
+      end
     end
-  end
 
+    Flag = Data.define do
+      def resolve(f)
+        self
+      end
+
+      def rbs_type
+        '::Integer'
+      end
+    end
+
+    Bitfield32 = Data.define do
+      def resolve(f)
+        self
+      end
+
+      def rbs_type
+        '::Integer'
+      end
+    end
+
+    IndexedArray = Struct.new(:sub_type) do
+      def resolve(f)
+        self.sub_type = sub_type.resolve(f)
+        self
+      end
+
+      def rbs_type
+        'untyped'
+      end
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ynl
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Kasumi Hanazuki
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.1.0
+        version: 0.2.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.1.0
+        version: 0.2.1
 - !ruby/object:Gem::Dependency
   name: yaml
   requirement: !ruby/object:Gem::Requirement
@@ -45,12 +45,16 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".rspec"
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
 - Rakefile
 - lib/ynl.rb
 - lib/ynl/family.rb
 - lib/ynl/generator.rb
 - lib/ynl/models.rb
 - lib/ynl/parser.rb
+- lib/ynl/version.rb
 - test.rb
 homepage: https://github.com/hanazuki/nl
 licenses:
@@ -73,7 +77,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.8
+rubygems_version: 4.0.3
 specification_version: 4
 summary: Linux Netlink - core
 test_files: []