Add RBS inline annotations and generated RBS files for Redhound classes

Author: ydah

.gem_rbs_collection/rake/13.0/.rbs_meta.yaml

@@ -0,0 +1,9 @@
+---
+name: rake
+version: '13.0'
+source:
+  type: git
+  name: ruby/gem_rbs_collection
+  revision: f83c613ed7d038c0031f25fcbcdf12603ba36e79
+  remote: https://github.com/ruby/gem_rbs_collection.git
+  repo_dir: gems

.gem_rbs_collection/rake/13.0/manifest.yaml

@@ -0,0 +1,2 @@
+dependencies:
+  - name: fileutils

.gem_rbs_collection/rake/13.0/rake.rbs

@@ -0,0 +1,39 @@
+module Rake
+  class TaskLib
+    include Rake::DSL
+  end
+
+  class Task
+  end
+
+  class TaskArguments
+    include Enumerable[untyped]
+
+    def []: (untyped index) -> untyped
+    def each: () ?{ (untyped, untyped) -> void } -> void
+  end
+
+  module DSL
+    private
+
+    include FileUtils
+
+    def desc: (String description) -> void
+    def directory: (*untyped args) ?{ () -> void } -> void
+    def file: (*untyped args) ?{ () -> void } -> void
+    def file_create: (*untyped args) ?{ () -> void } -> void
+    def import: (*String fns) -> void
+    def multitask: (*untyped args) ?{ () -> void } -> void
+    def namespace: (?untyped name) ?{ () -> void } -> void
+    def rule: (*untyped args) ?{ () -> void } -> void
+    def task: (*untyped args) ?{ (Rake::Task, Rake::TaskArguments) -> void } -> void
+  end
+end
+
+module FileUtils
+  def sh: (*String cmd, **untyped options) ?{ (bool, Process::Status) -> void } -> void
+    | (Hash[String, String] env, *String cmd, **untyped options) ?{ (bool, Process::Status) -> void } -> void
+  def ruby: (*String args, **untyped options) ?{ (bool, Process::Status) -> void } -> void
+  def safe_ln: (*untyped args, **untyped options) -> void
+  def split_all: (String path) -> Array[String]
+end

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'