Add RBS inline annotations and generated RBS files for Redhound classes

Author: ydah

.gitignore

@@ -1,6 +1,9 @@
 /.bundle/
 /.yardoc
+/.gem_rbs_collection/
 /_yardoc/
+/.irbrc
+/.vscode/
 /coverage/
 /doc/
 /pkg/

Steepfile

@@ -1,32 +1,4 @@
-# D = Steep::Diagnostic
-#
-# target :lib do
-#   signature "sig"
-#   ignore_signature "sig/test"
-#
-#   check "lib"                       # Directory name
-#   check "path/to/source.rb"         # File name
-#   check "app/models/**/*.rb"        # Glob
-#   # ignore "lib/templates/*.rb"
-#
-#   # library "pathname"              # Standard libraries
-#   # library "strong_json"           # Gems
-#
-#   # configure_code_diagnostics(D::Ruby.default)      # `default` diagnostics setting (applies by default)
-#   # configure_code_diagnostics(D::Ruby.strict)       # `strict` diagnostics setting
-#   # configure_code_diagnostics(D::Ruby.lenient)      # `lenient` diagnostics setting
-#   # configure_code_diagnostics(D::Ruby.silent)       # `silent` diagnostics setting
-#   # configure_code_diagnostics do |hash|             # You can setup everything yourself
-#   #   hash[D::Ruby::NoMethod] = :information
-#   # end
-# end
-
-# target :test do
-#   unreferenced!                     # Skip type checking the `lib` code when types in `test` target is changed
-#   signature "sig/test"              # Put RBS files for tests under `sig/test`
-#   check "test"                      # Type check Ruby scripts under `test`
-#
-#   configure_code_diagnostics(D::Ruby.lenient)      # Weak type checking for test code
-#
-#   # library "pathname"              # Standard libraries
-# end
+target :lib do
+  signature "sig"
+  check "lib"
+end

lib/redhound/analyzer.rb

@@ -1,30 +1,34 @@
+# rbs_inline: enabled
 # frozen_string_literal: true
 
 module Redhound
   class Analyzer
+    # @rbs (msg: String, count: Integer) -> void
     def self.analyze(msg:, count:)
       new(msg:, count:).analyze
     end
 
+    # @rbs (msg: String, count: Integer) -> void
     def initialize(msg:, count:)
       @msg = msg
       @count = count
     end
 
+    # @rbs () -> void
     def analyze
       l2 = L2::Ether.generate(bytes: @msg.bytes[0..], count: @count)
       l2.dump
       return unless l2.supported_type?
 
       l3 = L3::Resolver.resolve(bytes: @msg.bytes[l2.size..], l2:)
+      return if !l3 || @msg.bytes.size <= l2.size + l3.size
       l3.dump
-      return if @msg.bytes.size <= l2.size + l3.size
       unless l3.supported_protocol?
         puts "    └─ Unsupported protocol #{l3.protocol}"
         return
       end
 
-      L4::Resolver.resolve(bytes: @msg.bytes[(l2.size + l3.size)..], l3: l3).dump
+      L4::Resolver.resolve(bytes: @msg.bytes[(l2.size + l3.size)..], l3:)&.dump
     end
   end
 end

lib/redhound/builder/packet_mreq.rb

@@ -1,3 +1,4 @@
+# rbs_inline: enabled
 # frozen_string_literal: true
 
 require 'socket'
@@ -7,6 +8,7 @@ module Builder
     class PacketMreq
       PACKET_MR_PROMISC = 0x0001 # NOTE: netpacket/packet.h
 
+      # @rbs (ifname: String) -> void
       def initialize(ifname:)
         @ifname = ifname
       end
@@ -18,28 +20,34 @@ def initialize(ifname:)
       #   unsigned short mr_alen;       /* address length */
       #   unsigned char  mr_address[8]; /* physical-layer address */
       # };
+      # @rbs () -> String
       def build
         mr_ifindex + mr_type + mr_alen + mr_address
       end
 
+      # @rbs () -> String
       def mr_ifindex
         @mr_ifindex ||= [[index].pack('I')].pack('a4')
       end
 
       private
 
+      # @rbs () -> Integer?
       def index
         ::Socket.getifaddrs.find { |ifaddr| ifaddr.name == @ifname }&.ifindex
       end
 
+      # @rbs () -> String
       def mr_type
         @mr_type ||= [PACKET_MR_PROMISC].pack('S')
       end
 
+      # @rbs () -> String
       def mr_alen
         @mr_alen ||= [0].pack('S')
       end
 
+      # @rbs () -> String
       def mr_address
         @mr_address ||= [0].pack('C') * 8
       end

lib/redhound/builder/socket.rb

@@ -1,3 +1,4 @@
+# rbs_inline: enabled
 # frozen_string_literal: true
 
 require 'socket'
@@ -11,15 +12,18 @@ class Socket
       PACKED_ETH_P_ALL = [ETH_P_ALL].pack('S').unpack1('S>')
 
       class << self
+        # @rbs (ifname: String) -> Redhound::Source::Socket
         def build(ifname:)
           new(ifname:).build
         end
       end
 
+      # @rbs (ifname: String) -> void
       def initialize(ifname:)
         @mq_req = PacketMreq.new(ifname:)
       end
 
+      # @rbs () -> Redhound::Source::Socket
       def build
         socket = ::Socket.new(::Socket::AF_PACKET, ::Socket::SOCK_RAW, ETH_P_ALL)
         socket.bind([::Socket::AF_PACKET, PACKED_ETH_P_ALL, @mq_req.mr_ifindex].pack('SS>a16'))

lib/redhound/command.rb

@@ -1,14 +1,17 @@
+# rbs_inline: enabled
 # frozen_string_literal: true
 
 require 'optparse'
 require 'socket'
 
 module Redhound
   class Command
+    # @rbs () -> void
     def initialize
       @options = { ifname: nil }
     end
 
+    # @rbs (Array[untyped] argv) -> void
     def run(argv)
       parse(argv)
       if @options[:ifname].nil?
@@ -18,8 +21,9 @@ def run(argv)
       Receiver.run(ifname: @options[:ifname], filename: @options[:filename])
     end
 
+    # @rbs (Array[untyped] argv) -> void
     def parse(argv)
-      OptionParser.new do |o|
+      OptionParser.new do |o| # steep:ignore
         o.banner = <<~'BANNER' + <<~BANNER2
              ___         ____                     __
             / _ \___ ___/ / /  ___  __ _____  ___/ /
@@ -55,6 +59,7 @@ def parse(argv)
 
     private
 
+    # @rbs () -> void
     def list_interfaces
       ::Socket.getifaddrs.each { |ifaddr| puts ifaddr.name }
     end

lib/redhound/l2/ether.rb

@@ -1,54 +1,65 @@
+# rbs_inline: enabled
 # frozen_string_literal: true
 
 module Redhound
   class L2
     class Ether
-      attr_reader :type
+      attr_reader :type #: Protocol
 
       class << self
+        # @rbs (bytes: Array[Integer], count: Integer) -> Redhound::L2::Ether
         def generate(bytes:, count:)
           new(bytes:, count:).generate
         end
       end
 
+      # @rbs (bytes: Array[Integer], count: Integer) -> void
       def initialize(bytes:, count:)
         raise ArgumentError, "bytes must be #{size} bytes" unless bytes.size >= size
 
         @bytes = bytes
         @count = count
       end
 
+      # @rbs () -> Integer
       def size = 14
 
+      # @rbs () -> Redhound::L2::Ether
       def generate
         @dhost = @bytes[0..5]
         @shost = @bytes[6..11]
         @type = Protocol.new(protocol: hex_type(@bytes[12..13]))
         self
       end
 
+      # @rbs () -> void
       def dump
         puts self
       end
 
+      # @rbs () -> String
       def to_s
         "[#{@count}] Ethernet Dst: #{dhost} Src: #{shost} Type: #{@type}"
       end
 
+      # @rbs () -> bool
+      def supported_type?
+        @type.ipv4? || @type.ipv6? || @type.arp? # steep:ignore
+      end
+
+      private
+
+      # @rbs () -> String
       def dhost
         @dhost.map { |b| b.to_s(16).rjust(2, '0') }.join(':')
       end
 
+      # @rbs () -> String
       def shost
         @shost.map { |b| b.to_s(16).rjust(2, '0') }.join(':')
       end
 
-      def supported_type?
-        @type.ipv4? || @type.ipv6? || @type.arp?
-      end
-
-      private
-
+      # @rbs (Array[Integer] type) -> Integer
       def hex_type(type)
         type.map { |b| b.to_s(16).rjust(2, '0') }.join.to_i(16)
       end

lib/redhound/l2/protocol.rb

@@ -1,3 +1,4 @@
+# rbs_inline: enabled
 # frozen_string_literal: true
 
 module Redhound
@@ -11,10 +12,12 @@ class Protocol
         0x8100 => 'VLAN',
       }
 
+      # @rbs (protocol: Integer) -> void
       def initialize(protocol:)
         @protocol = protocol
       end
 
+      # @rbs () -> String
       def to_s
         PROTO_TABLE[@protocol] || 'Unknown'
       end

lib/redhound/l3.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'l3/arp'
+require_relative 'l3/base'
 require_relative 'l3/ipv4'
 require_relative 'l3/ipv6'
 require_relative 'l3/protocol'

lib/redhound/l3/arp.rb

@@ -1,20 +1,24 @@
+# rbs_inline: enabled
 # frozen_string_literal: true
 
 module Redhound
   class L3
-    class Arp
+    class Arp < Base
       class << self
+        # @rbs (bytes: Array[Integer]) -> Redhound::L3::Arp
         def generate(bytes:)
           new(bytes:).generate
         end
       end
 
+      # @rbs (bytes: Array[Integer]) -> void
       def initialize(bytes:)
         raise ArgumentError, "bytes must be bigger than #{arp_size} bytes" unless bytes.size >= arp_size
 
         @bytes = bytes
       end
 
+      # @rbs () -> Redhound::L3::Arp
       def generate
         @htype = @bytes[0..1]
         @ptype = @bytes[2..3]
@@ -30,8 +34,10 @@ def generate
         self
       end
 
+      # @rbs () -> Integer
       def arp_size = 28
 
+      # @rbs () -> Integer
       def size
         if @l3.nil?
           arp_size
@@ -40,52 +46,60 @@ def size
         end
       end
 
-      def dump
-        puts self
-      end
-
+      # @rbs () -> String
       def to_s
         "    └─ ARP HType: #{htype} PType: #{ptype} HLen: #{@hlen} PLen: #{@plen} Oper: #{oper} SHA: #{sha} SPA: #{spa} THA: #{tha} TPA: #{tpa}"
       end
 
+      # @rbs () -> bool
       def supported_protocol?
-        @l3.supported_protocol? if @l3
+        return false if @l3.nil?
+        @l3.supported_protocol?
       end
 
+      # @rbs () -> String?
       def protocol
         @l3.protocol if @l3
       end
 
       private
 
+      # @rbs () -> Integer
       def htype
         @htype.map { |b| b.to_s(16).rjust(2, '0') }.join.to_i(16)
       end
 
+      # @rbs () -> Integer
       def ptype
         @ptype.map { |b| b.to_s(16).rjust(2, '0') }.join.to_i(16)
       end
 
+      # @rbs () -> Integer
       def oper
         @oper.map { |b| b.to_s(16).rjust(2, '0') }.join.to_i(16)
       end
 
+      # @rbs () -> String
       def sha
         @sha.map { |b| b.to_s(16).rjust(2, '0') }.join(':')
       end
 
+      # @rbs () -> String
       def spa
         @spa.map { |b| b.to_s(16).rjust(2, '0') }.join('.')
       end
 
+      # @rbs () -> String
       def tha
         @tha.map { |b| b.to_s(16).rjust(2, '0') }.join(':')
       end
 
+      # @rbs () -> String
       def tpa
         @tpa.map { |b| b.to_s(16).rjust(2, '0') }.join('.')
       end
 
+      # @rbs () -> Redhound::L3::Base?
       def generate_l3
         return if @bytes.size == arp_size