vanken 0.1.0

data/sig/generated/vanken/config/preferences.rbs

@@ -0,0 +1,49 @@
+# Generated from lib/vanken/config/preferences.rb with RBS::Inline
+
+module Vanken
+  module Config
+    module Paths
+      def self.config: () -> untyped
+
+      def self.state: () -> untyped
+    end
+
+    class Preferences
+      DEFAULTS: untyped
+
+      attr_reader warning: untyped
+
+      attr_reader directory: untyped
+
+      def initialize: (?directory: untyped) -> untyped
+
+      def get: (untyped path) -> untyped
+
+      def set: (untyped path, untyped value) -> untyped
+
+      def history: () -> untyped
+
+      def recent_files: () -> untyped
+
+      def bookmarks: () -> untyped
+
+      def remember_filter: (untyped expression) -> untyped
+
+      def remember_file: (untyped path) -> untyped
+
+      def bookmark: (untyped name, untyped expression) -> untyped
+
+      def save: () -> untyped
+
+      private
+
+      def remember: (untyped key, untyped value, untyped limit) -> untyped
+
+      def merge: (untyped base, untyped saved) -> untyped
+
+      def validate: () -> untyped
+
+      def validate_shape: (untyped default, untyped value) -> untyped
+    end
+  end
+end

data/sig/generated/vanken/core/display_filter/compiler.rbs

@@ -0,0 +1,45 @@
+# Generated from lib/vanken/core/display_filter/compiler.rb with RBS::Inline
+
+module Vanken
+  module Core
+    module DisplayFilter
+      class Program
+        attr_reader expression: String
+
+        attr_reader fields: Array[String]
+
+        attr_reader sources: Array[Symbol]
+
+        attr_reader warnings: Array[String]
+
+        # @rbs (expression: String, fields: Array[String], sources: Array[Symbol], warnings: Array[String], evaluator: ^(untyped) -> bool) -> void
+        def initialize: (expression: String, fields: Array[String], sources: Array[Symbol], warnings: Array[String], evaluator: ^(untyped) -> bool) -> void
+
+        # @rbs (_FilterView view) -> bool
+        def match?: (_FilterView view) -> bool
+
+        # @rbs () -> bool
+        def fast?: () -> bool
+      end
+
+      class Compiler
+        # @rbs (?catalog: untyped) -> void
+        def initialize: (?catalog: untyped) -> void
+
+        # @rbs (String expression) -> Program
+        def compile: (String expression) -> Program
+
+        private
+
+        # @rbs (Node node) -> ^(untyped) -> bool
+        def compile_node: (Node node) -> ^(untyped) -> bool
+
+        # @rbs (Node node) -> ^(untyped) -> bool
+        def compile_test: (Node node) -> ^(untyped) -> bool
+      end
+
+      # @rbs (String expression, ?catalog: untyped) -> Program
+      def self.compile: (String expression, ?catalog: untyped) -> Program
+    end
+  end
+end

data/sig/generated/vanken/core/display_filter/errors.rbs

@@ -0,0 +1,16 @@
+# Generated from lib/vanken/core/display_filter/errors.rb with RBS::Inline
+
+module Vanken
+  module Core
+    module DisplayFilter
+      class SyntaxError < StandardError
+        attr_reader position: Integer
+
+        attr_reader length: Integer
+
+        # @rbs (String message, position: Integer, ?length: Integer) -> void
+        def initialize: (String message, position: Integer, ?length: Integer) -> void
+      end
+    end
+  end
+end

data/sig/generated/vanken/core/display_filter/field_resolver.rbs

@@ -0,0 +1,48 @@
+# Generated from lib/vanken/core/display_filter/field_resolver.rb with RBS::Inline
+
+module Vanken
+  module Core
+    module DisplayFilter
+      class Reference < Data
+        attr_reader name(): String
+
+        attr_reader type(): field_type?
+
+        attr_reader source(): Symbol
+
+        attr_reader protocol(): bool
+
+        attr_reader known(): bool
+
+        def self.new: (String name, field_type? type, Symbol source, bool protocol, bool known) -> instance
+                    | (name: String, type: field_type?, source: Symbol, protocol: bool, known: bool) -> instance
+
+        def self.members: () -> [ :name, :type, :source, :protocol, :known ]
+
+        def members: () -> [ :name, :type, :source, :protocol, :known ]
+      end
+
+      class FieldResolver
+        PROTOCOLS: untyped
+
+        FRAME_FIELDS: untyped
+
+        VIRTUAL_FIELDS: untyped
+
+        # @rbs (?untyped catalog) -> void
+        def initialize: (?untyped catalog) -> void
+
+        # @rbs (String name) -> Reference
+        def resolve: (String name) -> Reference
+
+        # @rbs (untyped type) -> field_type?
+        def normalize_type: (untyped type) -> field_type?
+
+        private
+
+        # @rbs (untyped entry, Symbol key) -> untyped
+        def metadata: (untyped entry, Symbol key) -> untyped
+      end
+    end
+  end
+end

data/sig/generated/vanken/core/display_filter/lexer.rbs

@@ -0,0 +1,49 @@
+# Generated from lib/vanken/core/display_filter/lexer.rb with RBS::Inline
+
+module Vanken
+  module Core
+    module DisplayFilter
+      class Token < Data
+        attr_reader type(): Symbol
+
+        attr_reader value(): untyped
+
+        attr_reader position(): Integer
+
+        attr_reader length(): Integer
+
+        attr_reader raw(): String
+
+        def self.new: (Symbol type, untyped value, Integer position, Integer length, String raw) -> instance
+                    | (type: Symbol, value: untyped, position: Integer, length: Integer, raw: String) -> instance
+
+        def self.members: () -> [ :type, :value, :position, :length, :raw ]
+
+        def members: () -> [ :type, :value, :position, :length, :raw ]
+      end
+
+      class Lexer
+        OPERATORS: untyped
+
+        PUNCTUATION: untyped
+
+        # @rbs (String expression) -> void
+        def initialize: (String expression) -> void
+
+        # @rbs () -> Array[Token]
+        def tokens: () -> Array[Token]
+
+        private
+
+        # @rbs (Integer position) -> String
+        def read_string: (Integer position) -> String
+
+        # @rbs (String raw, Integer position) -> [Symbol, untyped]
+        def classify: (String raw, Integer position) -> [ Symbol, untyped ]
+
+        # @rbs (String message, Integer position, Integer length) -> bot
+        def fail_at: (String message, Integer position, Integer length) -> bot
+      end
+    end
+  end
+end

data/sig/generated/vanken/core/display_filter/parser.rbs

@@ -0,0 +1,95 @@
+# Generated from lib/vanken/core/display_filter/parser.rb with RBS::Inline
+
+module Vanken
+  module Core
+    module DisplayFilter
+      class Node < Data
+        attr_reader kind(): Symbol
+
+        attr_reader left(): untyped
+
+        attr_reader right(): untyped
+
+        def self.new: (Symbol kind, untyped left, untyped right) -> instance
+                    | (kind: Symbol, left: untyped, right: untyped) -> instance
+
+        def self.members: () -> [ :kind, :left, :right ]
+
+        def members: () -> [ :kind, :left, :right ]
+      end
+
+      class Predicate < Data
+        attr_reader operator(): Symbol
+
+        attr_reader values(): Array[Member]
+
+        attr_reader token(): Token
+
+        def self.new: (Symbol operator, Array[Member] values, Token token) -> instance
+                    | (operator: Symbol, values: Array[Member], token: Token) -> instance
+
+        def self.members: () -> [ :operator, :values, :token ]
+
+        def members: () -> [ :operator, :values, :token ]
+      end
+
+      class Member < Data
+        attr_reader first(): Token
+
+        attr_reader last(): Token?
+
+        def self.new: (Token first, Token? last) -> instance
+                    | (first: Token, last: Token?) -> instance
+
+        def self.members: () -> [ :first, :last ]
+
+        def members: () -> [ :first, :last ]
+      end
+
+      class Parser
+        PRECEDENCE: untyped
+
+        VALUES: untyped
+
+        RELATIONS: untyped
+
+        attr_reader warnings: Array[String]
+
+        # @rbs (String expression) -> void
+        def initialize: (String expression) -> void
+
+        # @rbs () -> Node
+        def parse: () -> Node
+
+        private
+
+        # @rbs (Integer minimum) -> Node
+        def expression: (Integer minimum) -> Node
+
+        # @rbs () -> Node
+        def primary: () -> Node
+
+        # @rbs () -> Predicate?
+        def predicate: () -> Predicate?
+
+        # @rbs () -> Array[Member]
+        def set_members: () -> Array[Member]
+
+        # @rbs () -> Token
+        def value: () -> Token
+
+        # @rbs (Symbol type) -> Token
+        def expect_token: (Symbol type) -> Token
+
+        # @rbs () -> Token
+        def current: () -> Token
+
+        # @rbs () -> Token
+        def advance: () -> Token
+
+        # @rbs (String message, Token token) -> bot
+        def fail_at: (String message, Token token) -> bot
+      end
+    end
+  end
+end

data/sig/generated/vanken/core/display_filter/types.rbs

@@ -0,0 +1,45 @@
+# Generated from lib/vanken/core/display_filter/types.rb with RBS::Inline
+
+module Vanken
+  module Core
+    module DisplayFilter
+      module Types
+        NUMERIC: untyped
+
+        ORDERED: untyped
+
+        SEVERITIES: untyped
+
+        # @rbs (Predicate predicate, field_type? type) -> ^(untyped, field_type?) -> bool
+        def self?.predicate: (Predicate predicate, field_type? type) -> ^(untyped, field_type?) -> bool
+
+        # @rbs (Symbol operator, field_type? type, Token token) -> void
+        def self?.validate_operator: (Symbol operator, field_type? type, Token token) -> void
+
+        # @rbs (Array[Member] members, field_type? type) -> Array[prepared_member]
+        def self?.prepare_members: (Array[Member] members, field_type? type) -> Array[prepared_member]
+
+        # @rbs (Token token, field_type? type) -> untyped
+        def self?.literal: (Token token, field_type? type) -> untyped
+
+        # @rbs (untyped value, field_type? type) -> untyped
+        def self?.actual_value: (untyped value, field_type? type) -> untyped
+
+        # @rbs (untyped actual, Token token) -> field_type
+        def self?.infer_type: (untyped actual, Token token) -> field_type
+
+        # @rbs (untyped value, Symbol operator, Array[prepared_member] members, Regexp? regex, field_type? type) -> bool
+        def self?.compare: (untyped value, Symbol operator, Array[prepared_member] members, Regexp? regex, field_type? type) -> bool
+
+        # @rbs (untyped value) -> String
+        def self?.normalized_mac: (untyped value) -> String
+
+        # @rbs (Token token) -> Regexp
+        def self?.regular_expression: (Token token) -> Regexp
+
+        # @rbs (String message, Token token) -> bot
+        def self?.fail_at: (String message, Token token) -> bot
+      end
+    end
+  end
+end

data/sig/generated/vanken/core/frame.rbs

@@ -0,0 +1,63 @@
+# Generated from lib/vanken/core/frame.rb with RBS::Inline
+
+module Vanken
+  module Core
+    class Frame < Data
+      attr_reader bytes(): String
+
+      attr_reader timestamp_ns(): Integer
+
+      attr_reader original_length(): Integer
+
+      attr_reader linktype(): Integer
+
+      attr_reader interface(): Hash[String, untyped]?
+
+      attr_reader direction(): (:in | :out)?
+
+      attr_reader number(): Integer
+
+      def self.new: (String bytes, Integer timestamp_ns, Integer original_length, Integer linktype, Hash[String, untyped]? interface, (:in | :out)? direction, Integer number) -> instance
+                  | (bytes: String, timestamp_ns: Integer, original_length: Integer, linktype: Integer, interface: Hash[String, untyped]?, direction: (:in | :out)?, number: Integer) -> instance
+
+      def self.members: () -> [ :bytes, :timestamp_ns, :original_length, :linktype, :interface, :direction, :number ]
+
+      def members: () -> [ :bytes, :timestamp_ns, :original_length, :linktype, :interface, :direction, :number ]
+    end
+
+    class DetailNode < Data
+      attr_reader id(): String
+
+      attr_reader label(): String
+
+      attr_reader field(): String?
+
+      attr_reader offset(): Integer?
+
+      attr_reader length(): Integer
+
+      attr_reader source(): Symbol
+
+      attr_reader severity(): Symbol?
+
+      attr_reader filter(): String?
+
+      attr_reader children(): Array[DetailNode]
+
+      def self.new: (String id, String label, String? field, Integer? offset, Integer length, Symbol source, Symbol? severity, String? filter, Array[DetailNode] children) -> instance
+                  | (id: String, label: String, field: String?, offset: Integer?, length: Integer, source: Symbol, severity: Symbol?, filter: String?, children: Array[DetailNode]) -> instance
+
+      def self.members: () -> [ :id, :label, :field, :offset, :length, :source, :severity, :filter, :children ]
+
+      def members: () -> [ :id, :label, :field, :offset, :length, :source, :severity, :filter, :children ]
+    end
+
+    class DetailNode
+      # @rbs () -> Array[DetailNode]
+      def descendants: () -> Array[DetailNode]
+
+      # @rbs () -> Hash[Symbol, untyped]
+      def to_h: () -> Hash[Symbol, untyped]
+    end
+  end
+end

data/sig/generated/vanken/core/frame_store.rbs

@@ -0,0 +1,65 @@
+# Generated from lib/vanken/core/frame_store.rb with RBS::Inline
+
+module Vanken
+  module Core
+    class FrameStore
+      RECORD: ::String
+
+      RECORD_SIZE: ::Integer
+
+      DIRECTION_IDS: Hash[Symbol?, Integer]
+
+      MIN_TIMESTAMP: Integer
+
+      MAX_TIMESTAMP: Integer
+
+      attr_reader directory: String
+
+      @interfaces: Array[Hash[String, untyped]]
+
+      # @rbs (?parent: String?, ?directory: String?, ?recover: bool) -> void
+      def initialize: (?parent: String?, ?directory: String?, ?recover: bool) -> void
+
+      # @rbs (String directory) -> FrameStore
+      def self.recover: (String directory) -> FrameStore
+
+      # @rbs () -> Integer
+      def count: () -> Integer
+
+      # @rbs () -> Integer
+      # Published only after both files flush; reading the immutable count must not wait for writer IO.
+      def durable_count: () -> Integer
+
+      # @rbs (Frame frame) -> Integer
+      def append: (Frame frame) -> Integer
+
+      # @rbs () -> self
+      def flush: () -> self
+
+      # @rbs (Integer number) -> frame_metadata
+      def metadata: (Integer number) -> frame_metadata
+
+      # @rbs (Integer number) -> Frame
+      def read: (Integer number) -> Frame
+
+      # @rbs () -> Array[Hash[String, untyped]]
+      def interfaces: () -> Array[Hash[String, untyped]]
+
+      # @rbs (?remove: bool) -> void
+      def close: (?remove: bool) -> void
+
+      private
+
+      # @rbs (String name, String mode) -> File
+      def private_file: (String name, String mode) -> File
+
+      def validate_directory: () -> untyped
+
+      def persist: (untyped name, untyped value) -> untyped
+
+      def intern_interface: (untyped value) -> untyped
+
+      def restore: () -> untyped
+    end
+  end
+end

data/sig/generated/vanken/core/frame_view.rbs

@@ -0,0 +1,36 @@
+# Generated from lib/vanken/core/frame_view.rb with RBS::Inline
+
+module Vanken
+  module Core
+    class FrameView
+      # @rbs (App::Document document, Integer number, ?packet: Gateway::PacketView?, ?snapshot: Hash[Symbol, untyped]?) -> void
+      def initialize: (App::Document document, Integer number, ?packet: Gateway::PacketView?, ?snapshot: Hash[Symbol, untyped]?) -> void
+
+      # @rbs (String name) -> bool
+      def layer?: (String name) -> bool
+
+      # @rbs (String name) -> Symbol?
+      def field_type: (String name) -> Symbol?
+
+      # @rbs (String name) -> Array[untyped]
+      def values: (String name) -> Array[untyped]
+
+      private
+
+      # @rbs () -> frame_metadata
+      def metadata: () -> frame_metadata
+
+      # @rbs () -> column_values
+      def column: () -> column_values
+
+      # @rbs () -> annotation_values
+      def annotation: () -> annotation_values
+
+      # @rbs () -> Gateway::PacketView | Gateway::PacketSnapshot
+      def packet: () -> Gateway::PacketView
+
+      # @rbs () -> Float
+      def displayed_delta: () -> Float
+    end
+  end
+end

data/sig/generated/vanken/core/stores.rbs

@@ -0,0 +1,110 @@
+# Generated from lib/vanken/core/stores.rb with RBS::Inline
+
+module Vanken
+  module Core
+    class InternTable
+      # @rbs! @values: Array[String]
+      # @rbs! @ids: Hash[String, Integer]
+      # @rbs () -> void
+      def initialize: () -> void
+
+      # @rbs (String value) -> Integer
+      def intern: (String value) -> Integer
+
+      # @rbs (Integer id) -> String
+      def []: (Integer id) -> String
+
+      # @rbs () -> Integer
+      def size: () -> Integer
+
+      # @rbs (Integer index) -> Array[String]
+      def since: (Integer index) -> Array[String]
+    end
+
+    class ColumnStore
+      FORMAT: ::String
+
+      SIZE: ::Integer
+
+      attr_reader strings: InternTable
+
+      # @rbs! @protocol_ids: Hash[String, Integer]
+      # @rbs! @protocol_names: Array[String]
+      # @rbs! @transport_values: Hash[Integer, Hash[String, Array[Integer]]]
+      # @rbs! @base: Integer
+      # @rbs! @string_cursor: Integer
+      # @rbs! @protocol_cursor: Integer
+      # @rbs () -> void
+      def initialize: () -> void
+
+      # @rbs (column_values values) -> void
+      def append: (column_values values) -> void
+
+      # Transfer a batch without retaining a second copy of every frame in the worker.
+      # @rbs () -> Hash[Symbol, untyped]
+      def drain: () -> Hash[Symbol, untyped]
+
+      # @rbs (Hash[Symbol, untyped] batch) -> void
+      def import: (Hash[Symbol, untyped] batch) -> void
+
+      # @rbs (Integer number) -> column_values
+      def []: (Integer number) -> column_values
+
+      # @rbs (Integer number, String name) -> bool?
+      def layer?: (Integer number, String name) -> bool?
+
+      # @rbs (Integer number, String name) -> Array[Integer]
+      def port_values: (Integer number, String name) -> Array[Integer]
+    end
+
+    class AnnotationStore
+      FLAGS: untyped
+
+      FORMAT: ::String
+
+      SIZE: ::Integer
+
+      attr_reader streams: Hash[Integer, Array[Integer]]
+
+      attr_reader experts: Hash[Integer, Array[Hash[Symbol, untyped]]]
+
+      # @rbs! @extra: Hash[Integer, Hash[String, untyped]]
+      # @rbs! @io: File?
+      # @rbs (String directory, ?persist: bool) -> void
+      def initialize: (String directory, ?persist: bool) -> void
+
+      # @rbs (Integer number, annotation_values annotation) -> void
+      def append: (Integer number, annotation_values annotation) -> void
+
+      # @rbs () -> Hash[Symbol, untyped]
+      def drain: () -> Hash[Symbol, untyped]
+
+      # @rbs (Hash[Symbol, untyped] batch) -> void
+      def import: (Hash[Symbol, untyped] batch) -> void
+
+      # @rbs (Integer number) -> annotation_values
+      def []: (Integer number) -> annotation_values
+
+      # @rbs () -> void
+      def flush: () -> void
+
+      # @rbs (String path) -> String
+      def snapshot: (String path) -> String
+
+      # @rbs () -> void
+      def close: () -> void
+    end
+
+    class RowCache
+      # @rbs! @entries: Hash[untyped, untyped]
+      # @rbs (?limit: Integer) -> void
+      def initialize: (?limit: Integer) -> void
+
+      # @rbs [T] (untyped key) { () -> T } -> T
+      def fetch: [T] (untyped key) { () -> T } -> T
+
+      # @rbs () -> void
+      def clear: () -> void
+    end
+  end
+end

data/sig/generated/vanken/errors.rbs

@@ -0,0 +1,18 @@
+# Generated from lib/vanken/errors.rb with RBS::Inline
+
+module Vanken
+  class Error < StandardError
+  end
+
+  class FileError < Error
+  end
+
+  class CaptureError < Error
+  end
+
+  class ConfigError < Error
+  end
+
+  class FilterError < Error
+  end
+end

data/sig/generated/vanken/gateway/capture_filter.rbs

@@ -0,0 +1,17 @@
+# Generated from lib/vanken/gateway/capture_filter.rb with RBS::Inline
+
+module Vanken
+  module Gateway
+    module CaptureFilter
+      class Error < StandardError
+        attr_reader position: Integer?
+
+        # @rbs (String message, ?position: Integer?) -> void
+        def initialize: (String message, ?position: Integer?) -> void
+      end
+
+      # @rbs (String expression, ?linktype: Integer, ?snaplen: Integer, ?live: bool) -> Redhound::Filter::Program
+      def self.compile: (String expression, ?linktype: Integer, ?snaplen: Integer, ?live: bool) -> Redhound::Filter::Program
+    end
+  end
+end

data/sig/generated/vanken/gateway/detail_builder.rbs

@@ -0,0 +1,21 @@
+# Generated from lib/vanken/gateway/detail_builder.rb with RBS::Inline
+
+module Vanken
+  module Gateway
+    class DetailBuilder
+      # @rbs (PacketView packet, ?annotations: Core::annotation_values?) -> Array[Core::DetailNode]
+      def build: (PacketView packet, ?annotations: Core::annotation_values?) -> Array[Core::DetailNode]
+
+      private
+
+      # @rbs (untyped value, ?Symbol? type) -> String
+      def literal: (untyped value, ?Symbol? type) -> String
+
+      # @rbs (untyped value) -> String
+      def escape: (untyped value) -> String
+
+      # @rbs (String id, String label, ?field: String?, ?offset: Integer?, ?length: Integer, ?source: Symbol, ?severity: Symbol?, ?filter: String?, ?children: Array[Core::DetailNode]) -> Core::DetailNode
+      def node: (String id, String label, ?field: String?, ?offset: Integer?, ?length: Integer, ?source: Symbol, ?severity: Symbol?, ?filter: String?, ?children: Array[Core::DetailNode]) -> Core::DetailNode
+    end
+  end
+end