ynl 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b6a0856ea9a2918cc0a1dee7d9452227091209776df336059a4eae4ca85b903e
+  data.tar.gz: 4513210c607ad814734cc0ed03f5e57ed1853da3b86539015a933db6364c5205
+SHA512:
+  metadata.gz: ba1fd6ff654ad9c613e98ddcbdf9e28e3b9b24eac873f5e1c19aa2cfa919e2020bc9c7557691d235554f72cc279f89e4612027aef1feaeda43c3d9a98201f76d
+  data.tar.gz: 39ca59b427aa8d8c945350a351518063407583e7e511acf0e4ed5ba901b860dbab65b32daaf0a1218ccdbf7fddd6d0a5c826761f80393f88b361159a8fee4be9

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/lib/ynl/family.rb

@@ -0,0 +1,20 @@
+require 'stringio'
+
+require_relative 'parser'
+require_relative 'generator'
+
+module Ynl
+  class Family
+    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
+
+      Module.new { eval(classdef) }.const_get(classname)
+    end
+  end
+end

data/lib/ynl/generator.rb

@@ -0,0 +1,230 @@
+module Ynl
+  class Generator
+    module Refinements
+      WORD_DELIM = /[ _-]+/
+
+      refine(String) do
+        def as_const_name
+          split(WORD_DELIM).map(&:upcase).join('_')
+        end
+
+        def as_class_name
+          split(WORD_DELIM).map(&:capitalize).join
+        end
+
+        def as_variable_name
+          split(WORD_DELIM).join('_')
+        end
+        alias as_method_name as_variable_name
+
+        def as_string_literal
+          dump
+        end
+
+        def as_symbol_literal
+          ":#{dump}"
+        end
+      end
+    end
+    private_constant :Refinements
+
+    using Refinements
+
+    def initialize(ynl, out)
+      @ynl = ynl
+      @out = out
+      @indent = 0
+    end
+
+    def generate(superclass: '::Nl::Family', namespace: nil)
+      classname = @ynl.name.as_class_name
+      emit_class([*namespace, classname].join('::'), superclass) do
+        write('NAME = ', @ynl.name.as_string_literal)
+        write('PROTONUM = ', @ynl.protonum)
+
+        if @ynl.protocol == 'netlink-raw'
+          write('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, ')')
+        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(', ') ,')')
+            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(', ') ,'})')
+              write('def self.decode(decoder)')
+              indent do
+                write('self.new(*MEMBERS.map {|name, datatype| datatype.decode(decoder) })')
+              end
+              write('end')
+
+              write('def encode(encoder)')
+              indent do
+                write('MEMBERS.each {|name, datatype| datatype.encode(encoder, self.public_send(name)) }')
+              end
+              write('end')
+            end
+          end
+        end
+
+        emit_module('AttributeSets') do
+          @ynl.attribute_sets.each do |name, attr_set|
+            emit_comment(attr_set.doc)
+            emit_class(name.as_class_name, '::Nl::Family::AttributeSet') do
+              emit_comment("Abstract class")
+              emit_class('Attribute', '::Nl::Family::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))
+                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_singleton_class do
+                emit_rbs_comment(
+                  'name: Symbol',
+                  'return: Attribute',
+                )
+                write('def by_name(name) = BY_NAME[name]')
+
+                emit_rbs_comment(
+                  'type: Integer',
+                  'return: Attribute',
+                )
+                write('def by_type(type) = BY_TYPE[type]')
+              end
+            end
+          end
+        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)
+                    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(' ') ,'])')
+                  end
+                end
+              end
+            end
+          end
+        end
+
+        # emit request methods
+        @ynl.operations.each do |name, oper|
+          %w[do dump].each do |method|
+            if request_reply = oper.public_send(method + 'it')
+              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'
+                end
+                write("exchange_message(#{method.as_symbol_literal}, #{request_class}, #{reply_class}, args)")
+              end
+              write('end')
+            end
+          end
+        end
+      end
+
+      classname
+    end
+
+    INDENT = -'  '
+    NEWLINE = -?\n
+    private_constant :INDENT, :NEWLINE
+
+    private def write(*str)
+      @out.write(INDENT * @indent, *str, NEWLINE)
+    end
+
+    private def indent
+      @indent += 1
+      yield
+    ensure
+      @indent -= 1
+    end
+
+    private def emit_module(name)
+      write('module ', name)
+      indent { yield }
+      write('end')
+    end
+
+    private def emit_class(name, superclass = nil)
+      if superclass
+        write('class ', name, ' < ', superclass)
+      else
+        write('class ', name)
+      end
+      indent { yield }
+      write('end')
+    end
+
+    private def emit_singleton_class
+      write('class << self')
+      indent { yield }
+      write('end')
+    end
+
+    private def emit_comment(comment)
+      return unless comment
+      comment.each_line do |line|
+        write('# ', line)
+      end
+    end
+
+    private def emit_rbs_comment(*args)
+      args.each do |arg|
+        write('# @rbs ', arg)
+      end
+    end
+
+    private def to_datatype(type, checks)
+      case type
+      when Types::Pad
+        'nil'
+      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)})"
+      when Types::String
+        "PROTOCOL.class::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)})"
+        # end
+      when Types::NestedAttributes
+        "PROTOCOL.class::DataTypes::NestedAttributes.new(#{type.attribute_set.name.as_class_name})"
+      else
+        raise "Unknown type: #{type.class}"
+      end
+    end
+
+    private def to_checks(checks)
+      return 'nil' if !checks || checks.empty?
+      %Q{-> { #{checks.join('; ')} }}
+    end
+  end
+end

data/lib/ynl/models.rb

@@ -0,0 +1,156 @@
+module Ynl
+  module Models
+    Family = ::Struct.new(:name, :protocol, :protonum, :doc,
+      :consts, :enums, :flags, :structs,
+      :attribute_sets, :sub_messages, :operations, :mcast_groups)
+    class Family
+      def resolve
+        structs.transform_values! {|s| s.resolve(self) }
+        attribute_sets.transform_values! {|s| s.resolve(self) }
+        self
+      end
+
+      def find_type(name)
+        enums[name] or flags[name] or structs[name] or raise ParseError, "Unknown type: #{name}"
+      end
+    end
+
+    class Thunk
+      def initialize(&block)
+        @block = block
+      end
+
+      def resolve(f)
+        raise ParseError, "Circular dependency" if @resolving
+        @resolving = true
+        @block.call(f)
+      end
+    end
+
+    class Enum
+      Entry = ::Struct.new(:name, :value, :doc)
+
+      attr_reader :name, :entries, :doc
+
+      def initialize(name:, doc:)
+        @name = name
+        @entries = []
+        @doc = doc
+      end
+
+      def resolve(f)
+        self
+      end
+    end
+
+    class Flags
+      Entry = ::Struct.new(:name, :value, :doc)
+
+      attr_reader :name, :entries, :doc
+
+      def initialize(name:, doc:)
+        @name = name
+        @entries = []
+        @doc = doc
+      end
+
+      def resolve(f)
+        self
+      end
+    end
+
+    class Struct
+      Member = ::Struct.new(:name, :type, :doc) do
+        def resolve(f)
+          self.type = self.type.resolve(f)
+          self
+        end
+      end
+
+      attr_reader :name, :members, :doc
+
+      def initialize(name:, doc:)
+        @name = name
+        @members = []
+        @doc = doc
+      end
+
+      def resolve(f)
+        @members.map! {|m| m.resolve(f) }
+        self
+      end
+    end
+
+    class AttributeSet
+      Attribute = ::Struct.new(:name, :type, :value, :checks, :doc) do
+        def resolve(f)
+          self.type = type.resolve(f)
+          self
+        end
+      end
+
+      attr_reader :name, :name_prefix, :attributes, :doc
+
+      def initialize(name:, name_prefix:, doc:)
+        @name = name
+        @name_prefix = name_prefix
+        @attributes = []
+        @doc = doc
+      end
+
+      def resolve(f)
+        attributes.map! { it.resolve(f) }
+        self
+      rescue
+        raise ParseError, "Failed to resolve attribute set: #{name}"
+      end
+    end
+
+    class Operation
+      attr_reader :name, :doc, :fixed_header, :attribute_set, :doit, :dumpit
+
+      def initialize(name:, doc:, fixed_header:, attribute_set:, doit:, dumpit:)
+        @name = name
+        @doc = doc
+        @fixed_header = fixed_header
+        @attribute_set = attribute_set
+        @doit = doit
+        @dumpit = dumpit
+      end
+
+      def resolve(f)
+        @doit = @doit.resolve(f)
+        @dumpit = @dumpit.resolve(f)
+        self
+      end
+    end
+
+    class RequestReply
+      attr_reader :request, :reply
+
+      def initialize(request:, reply:)
+        @request = request
+        @reply = reply
+      end
+
+      def resolve(f)
+        @request = @request.resolve(f)
+        @reply = @reply.resolve(f)
+        self
+      end
+    end
+
+    class Message
+      attr_reader :value, :attributes
+
+      def initialize(value:, attributes:)
+        @value = value
+        @attributes = attributes
+      end
+
+      def resolve(f)
+        self
+      end
+    end
+  end
+end

data/lib/ynl/parser.rb

@@ -0,0 +1,330 @@
+require 'yaml'
+
+require_relative 'models'
+
+module Ynl
+  class Parser
+    def initialize(source)
+      @yaml = YAML.load(source, aliases: true)
+
+      @consts = {}
+      @flags = {}
+      @enums = {}
+      @structs = {}
+
+      @attribute_sets = {}
+      @sub_messages = {}
+      @operations = {}
+      @mcast_groups = {}
+    end
+
+    def self.parse_file(path)
+      File.open(path) {|f| new(f) }.parse
+    end
+
+    def parse
+      protocol = @yaml['protocol'] || 'genetlink'
+      protonum = @yaml['protonum']
+      name = @yaml['name']
+      doc = @yaml['doc']
+
+      @yaml['definitions']&.each do |d|
+        parse_definition(d)
+      end
+      @yaml['attribute-sets'].each do |d|
+        parse_attribute_set(d)
+      end
+      @yaml['sub-messages']&.each do |d|
+        parse_sub_message(d)
+      end
+      if operations = @yaml['operations']
+        enum_model = case operations['enum-model']
+        when 'directional'
+          :directional
+        when nil
+          :unidirectional
+        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:)
+        end
+      end
+      @yaml['mcast-groups']&.each do |d|
+        parse_mcast_group(d)
+      end
+
+      Models::Family.new(
+        name:,
+        protocol:,
+        protonum:,
+        doc:,
+        consts: @consts,
+        enums: @enums,
+        flags: @flags,
+        structs: @structs,
+        attribute_sets: @attribute_sets,
+        sub_messages: @sub_messages,
+        operations: @operations,
+        mcast_groups: @mcast_groups,
+      ).resolve
+    end
+
+    private def parse_definition(d)
+      case type = d.fetch('type')
+      when 'const'
+        v = parse_const(d)
+        @consts[v.name] = v
+      when 'enum'
+        v = parse_enum_flags(d, type: :enum)
+        @enums[v.name] = v
+      when 'flags'
+        v = parse_enum_flags(d, type: :flags)
+        @flags[v.name] = v
+      when 'struct'
+        v = parse_struct(d)
+        @structs[v.name] = v
+      else
+        raise ParseError, "Unknown definition type: #{type}"
+      end
+    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'])
+
+      start_value = d['start-value'] || 0
+      value = type == :enum ? start_value : 1 << start_value
+
+      d.fetch('entries').each do |v|
+        case v
+        when String
+          entry = cls::Entry.new(name: v, value:)
+        when Hash
+          entry = cls::Entry.new(name: v.fetch('name'), value:, doc: v['doc'])
+        else
+          raise ParseError, "Unknown class for enum/flags entry: #{v.class}"
+        end
+
+        result.entries << entry
+
+        value = type == :enum ? value + 1 : value << 1
+
+      rescue
+        raise ParseError, "Failed to parse enum/flags entry: #{v.fetch('name')}"
+      end
+
+      result
+    rescue
+      raise ParseError, "Failed to parse enum/flags: #{d.fetch('name')}"
+    end
+
+    private def parse_struct_member_type(d)
+      type = d.fetch('type')
+      case type
+      when 'u8', 'u16', 'u32', 'u64', 's8', 's16', 's32', 's64', 'int', 'uint'
+        Types::Scalar.new(
+          type: type,
+          byte_order: parse_byte_order(d['byte-order']),
+        )
+      when 'binary'
+        Types::Binary.new(
+          struct: d['struct'] ? Models::Thunk.new {|f| f.structs.fetch(d['struct']) } : nil,
+          display_hint: d['display-hint'],
+        )
+      when 'pad'
+        Types::Pad.new(
+          length: d['len'],
+        )
+      else
+        fail "Unknown type: #{type}"
+      end
+    end
+
+    private def parse_attribute_type(d)
+      type = d.fetch('type')
+      case type
+      when 'u8', 'u16', 'u32', 'u64', 's8', 's16', 's32', 's64', 'int', 'uint'
+        Types::Scalar.new(
+          type: type,
+          byte_order: parse_byte_order(d['byte-order']),
+        )
+      when 'binary'
+        Types::Binary.new(
+          struct: d['struct'] ? Models::Thunk.new {|f| f.structs.fetch(d.fetch('struct')) } : nil,
+          display_hint: d['display-hint'],
+        )
+      when 'string'
+        Types::String.new
+      when 'nest'
+        Types::NestedAttributes.new(
+          attribute_set: Models::Thunk.new {|f| f.attribute_sets.fetch(d.fetch('nested-attributes')) },
+        )
+      when 'sub-message'
+        Types::SubMessage.new(
+          sub_message: Models::Thunk.new {|f| f.sub_messages.fetch(d.fetch('sub-message')) },
+          selector: d.fetch('selector'),
+        )
+      when 'pad'
+        Types::Pad.new(
+          length: nil,
+        )
+      when 'unused'
+        nil
+      else
+        raise ParseError, "Unknown type: #{type}"
+      end
+    end
+
+    private def parse_byte_order(v)
+      case v
+      when nil
+        :host
+      when 'big-endian'
+        :big
+      when 'litten-endian'
+        :little
+      else
+        raise ParseError, "Unknown endian: #{v}"
+      end
+    end
+
+    private def parse_struct(d)
+      result = Models::Struct.new(name: d.fetch('name'), 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'])
+        result.members << member
+      rescue
+        raise ParseError, "Failed to parse struct member: #{v.fetch('name')}"
+      end
+
+      result
+    rescue
+      raise ParseError, "Failed to parse struct: #{d.fetch('name')}"
+    end
+
+    private def parse_checks(d)
+      d.map do |op, value|
+        parse_check(op, value)
+      end
+    rescue
+      raise ParseError, "Failed to parse checks"
+    end
+
+    private def parse_check(op, value_literal)
+      case op
+      when 'max'
+        value = parse_value(value_literal)
+        return %{raise unless it <= #{value}}
+      when 'min'
+        value = parse_value(value_literal)
+        return %{raise unless it >= #{value}}
+      when 'min-len'
+        value = parse_value(value_literal)
+        return %{raise unless it.bytesize >= #{value}}
+      when 'max-len'
+        value = parse_value(value_literal)
+        return %{raise unless it.bytesize <= #{value}}
+      else
+        raise ParseError, "Unknown check: #{op}"
+      end
+    rescue
+      raise ParseError, "Failed to parse check: #{op}"
+    end
+
+    private def parse_value(v)
+      case v
+      when Integer
+        v
+      when 'u32-max'
+        (2 ** 32) - 1
+      when 's32-max'
+        (2 ** 31) - 1
+      else
+        raise ParseError, "Unknown value: #{v}"
+      end
+    end
+
+    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
+      else
+        name_prefix = d['name_prefix']
+        result = Models::AttributeSet.new(name:, name_prefix:, doc: d['doc'])
+        value = 0
+
+        d.fetch('attributes').each do |v|
+          if type = parse_attribute_type(v)
+            value = v.fetch('value', value + 1)
+            attribute = Models::AttributeSet::Attribute.new(name: v.fetch('name'), type: type, value:)
+            result.attributes << attribute
+            if checks = v['checks']
+              attribute.checks = parse_checks(checks)
+            end
+          end
+        rescue
+          raise ParseError, "Failed to parse attribute: #{v.fetch('name')}"
+        end
+      end
+
+      @attribute_sets[name] = result
+
+    rescue
+      raise ParseError, "Failed to parse attribute set: #{d.fetch('name')}"
+    end
+
+    private def parse_sub_message(d)
+    end
+
+    private def parse_operation(d, enum_model:)
+      name = d.fetch('name')
+
+      fixed_header = d['fixed-header']&.then do
+        @structs.fetch(it)
+      rescue
+        raise ParseError, "Undefined fixed header: #{it}"
+      end || @default_fixed_header
+
+      attribute_set = d['attribute-set']&.then do
+        @attribute_sets.fetch(it)
+      rescue
+        raise ParseError, "Undefined attribute set: #{it}"
+      end
+
+      doit = d['do']&.then { parse_request_reply(it) }
+      dumpit = d['dump']&.then { parse_request_reply(it) }
+
+      @operations[name] = Models::Operation.new(name:, doc: d['doc'], fixed_header:, attribute_set:, doit:, dumpit:)
+    end
+
+    private def parse_request_reply(d)
+      Models::RequestReply.new(
+        request: d['request']&.then { parse_message(it) },
+        reply: d['reply']&.then { parse_message(it) },
+      )
+    end
+
+    private def parse_message(d)
+      Models::Message.new(value: d['value'], attributes: d.fetch('attributes', []))
+    end
+
+    private def parse_mcast_group(d)
+    end
+  end
+end

data/lib/ynl.rb

@@ -0,0 +1,47 @@
+# Parse for YNL netlink specification
+#
+# See: https://www.kernel.org/doc/html/latest/userspace-api/netlink/specs.html
+
+require_relative 'ynl/family'
+
+module Ynl
+  class ParseError < StandardError; end
+
+  module Types
+    Scalar = Data.define(:type, :byte_order) do
+      def resolve(f)
+        self
+      end
+    end
+    String = Struct.new do
+      def resolve(f)
+        self
+      end
+    end
+    Binary = Struct.new(:struct, :length, :display_hint) do
+      def resolve(f)
+        self.struct = struct.resolve(f) if self.struct
+        self
+      end
+    end
+    NestedAttributes = Struct.new(:attribute_set) do
+      def resolve(f)
+        self.attribute_set = attribute_set.resolve(f)
+        self
+      end
+    end
+    SubMessage = Struct.new(:sub_message, :selector) do
+      def resolve(f)
+        self.sub_message = sub_message.resolve(f)
+        self
+      end
+    end
+
+    Pad = Data.define(:length) do
+      def resolve(f)
+        self
+      end
+    end
+  end
+
+end

data/test.rb

@@ -0,0 +1,10 @@
+require 'nl'
+require 'ynl'
+yaml = File.join(__dir__, '../nl-linux/linux/rt_route.yaml')
+cls = Ynl::Family.build(yaml)
+
+#p result = cls.open.dump_getaddr(ifa_index: 1)
+p result = cls.open.dump_getroute(rtm_family: 1)
+binding.irb
+
+#p cls.open.dump_get_stats

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification
+name: ynl
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Kasumi Hanazuki
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: nl
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+- !ruby/object:Gem::Dependency
+  name: yaml
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Linux Netlink
+email:
+- kasumi@rollingapple.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- Rakefile
+- lib/ynl.rb
+- lib/ynl/family.rb
+- lib/ynl/generator.rb
+- lib/ynl/models.rb
+- lib/ynl/parser.rb
+- test.rb
+homepage: https://github.com/hanazuki/nl
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/hanazuki/nl
+  source_code_uri: https://github.com/hanazuki/nl
+  changelog_uri: https://github.com/hanazuki/nl/blob/master/ynl/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.8
+specification_version: 4
+summary: Linux Netlink - core
+test_files: []