herb 0.10.3-x86-linux-gnu → 0.11.0-x86-linux-gnu

data/sig/herb/backend.rbs

@@ -0,0 +1,52 @@
+# Generated from lib/herb/backend.rb with RBS::Inline
+
+module Herb
+  # What the native extension defines, declared in Ruby so that it can be read without reading C.
+  #
+  # Loading the extension reopens this module and defines each method for real, so nothing here
+  # runs in a working install. What is left when the extension does not load is a set of methods
+  # that say so, instead of the `NoMethodError` a missing definition would raise:
+  #
+  #     Herb::Backend.parse(source)
+  #     #=> NotImplementedError: Herb::Backend.parse is defined by the native extension, which did not load
+  #
+  # The public API is `Herb.parse` and its neighbours, which are Ruby and live in `lib/herb.rb`.
+  # This is only the seam they call through.
+  module Backend
+    module Unavailable
+      # : (String, **untyped) -> Herb::ParseResult
+      def parse: (String, **untyped) -> Herb::ParseResult
+
+      # : (String, **untyped) -> Herb::LexResult
+      def lex: (String, **untyped) -> Herb::LexResult
+
+      # : (String, **untyped) -> String
+      def extract_ruby: (String, **untyped) -> String
+
+      # : (String) -> String
+      def extract_html: (String) -> String
+
+      # : (String, String, **untyped) -> Herb::Diff::Result
+      def diff: (String, String, **untyped) -> Herb::Diff::Result
+
+      # : (**untyped) -> untyped
+      def arena_stats: (**untyped) -> untyped
+
+      # : (String) -> untyped
+      def leak_check: (String) -> untyped
+
+      # : () -> Array[String]
+      def default_erb_openings: () -> Array[String]
+
+      # : () -> String
+      def version: () -> String
+
+      private
+
+      # : (Symbol?) -> bot
+      def unavailable: (Symbol?) -> bot
+    end
+
+    extend Unavailable
+  end
+end

data/sig/herb/colors.rbs

@@ -8,6 +8,9 @@ module Herb
 
     CLEAR_SCREEN: ::String
 
+    # : [T] (bool) { () -> T } -> T
+    def self?.with_color: [T] (bool) { () -> T } -> T
+
     # : () -> bool
     def self?.enabled?: () -> bool
 

data/sig/herb/configuration.rbs

@@ -10,14 +10,18 @@ module Herb
 
     VALID_TEMPLATE_ENGINES: Array[String]
 
-    CONFIG_FILENAMES: untyped
+    CONFIG_FILENAMES: Array[String]
 
-    PROJECT_INDICATORS: untyped
+    MISNAMED_CONFIG_FILENAMES: Array[String]
+
+    PROJECT_INDICATORS: Array[String]
 
     DEFAULTS_PATH: untyped
 
     DEFAULTS: untyped
 
+    GLOB_CHARACTERS: Regexp
+
     attr_reader config: untyped
 
     attr_reader user_config: untyped
@@ -26,6 +30,8 @@ module Herb
 
     attr_reader project_root: untyped
 
+    attr_reader misnamed_config_paths: untyped
+
     def initialize: (?untyped project_path) -> untyped
 
     def []: (untyped key) -> untyped
@@ -46,6 +52,14 @@ module Herb
 
     def file_exclude_patterns: () -> untyped
 
+    def parser: () -> untyped
+
+    # : () -> Array[String]
+    def erb_openers: () -> Array[String]
+
+    # : () -> Hash[Symbol, untyped]
+    def parser_options: () -> Hash[Symbol, untyped]
+
     def linter: () -> untyped
 
     def engine: () -> untyped
@@ -75,14 +89,20 @@ module Herb
 
     def formatter_enabled_for_path?: (untyped path) -> untyped
 
-    def path_excluded?: (untyped path, untyped patterns) -> untyped
+    def path_excluded?: (untyped path, untyped patterns, ?untyped include_patterns) -> untyped
 
     def path_included?: (untyped path, untyped patterns) -> untyped
 
+    def include_overrides_exclude?: (untyped include_pattern, untyped exclude_pattern) -> untyped
+
+    def literal_prefix_segments: (untyped pattern) -> untyped
+
     def find_files: (?untyped search_path) -> untyped
 
     def find_files_for_tool: (untyped tool, ?untyped search_path) -> untyped
 
+    def collect_files: (untyped search_path, untyped include_patterns, untyped exclude_patterns) -> untyped
+
     def find_files_for_linter: (?untyped search_path) -> untyped
 
     def find_files_for_formatter: (?untyped search_path) -> untyped
@@ -99,6 +119,10 @@ module Herb
 
     def find_config_file: () -> untyped
 
+    def find_misnamed_config_paths: () -> untyped
+
+    def warn_about_misnamed_config_files: () -> untyped
+
     def project_root?: (untyped path) -> untyped
 
     def load_user_config: () -> untyped

data/sig/herb/dev/assets.rbs

@@ -0,0 +1,27 @@
+# Generated from lib/herb/dev/assets.rb with RBS::Inline
+
+module Herb
+  module Dev
+    # Tracks the build outputs a project's asset watchers write.
+    #
+    # A build tool rewrites its output on every run, and most runs change nothing,
+    # so only a moved digest counts as a change.
+    class Assets
+      ROOT: String
+
+      PATTERNS: Array[String]
+
+      # : () -> void
+      def initialize: () -> void
+
+      # : (String) -> Symbol
+      def self.kind_for: (String) -> Symbol
+
+      # : (String) -> void
+      def index: (String) -> void
+
+      # : (String) -> bool
+      def changed?: (String) -> bool
+    end
+  end
+end

data/sig/herb/dev/classifier.rbs

@@ -0,0 +1,57 @@
+# Generated from lib/herb/dev/classifier.rb with RBS::Inline
+
+module Herb
+  module Dev
+    # Says what kind of change an edit to a template is.
+    #
+    # The watcher hands it the previous and current source, and everything downstream decides
+    # what to do from the kind alone. `:none` and `:whitespace` render the same as before, so
+    # nothing needs to happen. `:static` moved markup without touching any ERB. `:dynamic` is
+    # everything else. `:parse_error` carries the errors instead of a diff.
+    #
+    # The kinds are ordered checks, and the whitespace check has to come before the patchable
+    # one. `whitespace_changed` is not a patchable operation, so a reindent classified in the
+    # wrong order would read as `:dynamic` and cost a page reload.
+    #
+    # The diff parses without the configured ERB openers, so a custom opener reads as text on
+    # both sides and its edits would pass the patchable check. With openers configured, no
+    # change classifies better than `:dynamic`.
+    class Classifier
+      PATCHABLE_TYPES: Array[String]
+
+      class Classification < Data
+        attr_reader kind(): Symbol
+
+        attr_reader operations(): Array[Herb::Diff::Operation]
+
+        attr_reader node_path(): Array[Integer]
+
+        attr_reader errors(): Array[Herb::Errors::Error]
+
+        def self.new: (Symbol kind, Array[Herb::Diff::Operation] operations, Array[Integer] node_path, Array[Herb::Errors::Error] errors) -> instance
+                    | (kind: Symbol, operations: Array[Herb::Diff::Operation], node_path: Array[Integer], errors: Array[Herb::Errors::Error]) -> instance
+
+        def self.members: () -> [ :kind, :operations, :node_path, :errors ]
+
+        def members: () -> [ :kind, :operations, :node_path, :errors ]
+      end
+
+      # : (Array[Herb::Diff::Operation]) -> bool
+      def self.can_patch?: (Array[Herb::Diff::Operation]) -> bool
+
+      # : (?configuration: Herb::Configuration?) -> void
+      def initialize: (?configuration: Herb::Configuration?) -> void
+
+      # : (String, String) -> Classification
+      def call: (String, String) -> Classification
+
+      private
+
+      # : (Symbol, ?operations: Array[Herb::Diff::Operation], ?node_path: Array[Integer], ?errors: Array[Herb::Errors::Error]) -> Classification
+      def classification: (Symbol, ?operations: Array[Herb::Diff::Operation], ?node_path: Array[Integer], ?errors: Array[Herb::Errors::Error]) -> Classification
+
+      # : (Array[Herb::Diff::Operation]) -> Array[Integer]
+      def covering_path: (Array[Herb::Diff::Operation]) -> Array[Integer]
+    end
+  end
+end

data/sig/herb/dev/embedded.rbs

@@ -0,0 +1,21 @@
+# Generated from lib/herb/dev/embedded.rb with RBS::Inline
+
+module Herb
+  module Dev
+    class Embedded
+      # : (Server, Watcher, Pipeline, Integer) -> void
+      def initialize: (Server, Watcher, Pipeline, Integer) -> void
+
+      attr_reader server: Server
+
+      attr_reader watcher: Watcher
+
+      attr_reader pipeline: Pipeline
+
+      attr_reader pid: Integer
+
+      # : () -> void
+      def stop: () -> void
+    end
+  end
+end

data/sig/herb/dev/pipeline.rbs

@@ -0,0 +1,118 @@
+# Generated from lib/herb/dev/pipeline.rb with RBS::Inline
+
+module Herb
+  module Dev
+    # Turns one watcher event into the messages the browsers need.
+    #
+    # The pipeline holds what it learned about every file so far. The version a file last
+    # compiled to says whether an edit changed the template's shape, the slot entries feed
+    # the remap, and the error state decides when a clean compile has to say so out loud.
+    # Parse errors and compile diagnostics live in the same state machine, so a template
+    # that stops compiling behaves exactly like one that stops parsing.
+    #
+    # The compiler is looked up per event. A host that registers one after the pipeline
+    # started is picked up on the next change.
+    class Pipeline
+      STATES: Array[Symbol]
+
+      class Failure < Struct[untyped]
+        attr_accessor mode(): untyped
+
+        attr_accessor manifest(): untyped
+
+        attr_accessor version(): untyped
+
+        attr_accessor slot_entries(): untyped
+
+        attr_accessor statics(): untyped
+
+        attr_accessor static_markup(): untyped
+
+        attr_accessor diagnostics(): untyped
+
+        def self.new: (?untyped mode, ?untyped manifest, ?untyped version, ?untyped slot_entries, ?untyped statics, ?untyped static_markup, ?untyped diagnostics) -> instance
+                    | (?mode: untyped, ?manifest: untyped, ?version: untyped, ?slot_entries: untyped, ?statics: untyped, ?static_markup: untyped, ?diagnostics: untyped) -> instance
+      end
+
+      # : (server: untyped, ?configuration: Herb::Configuration?, ?compiler: ^() -> Herb::Dev::_Compiler?) -> void
+      def initialize: (server: untyped, ?configuration: Herb::Configuration?, ?compiler: ^() -> Herb::Dev::_Compiler?) -> void
+
+      # : () { (untyped, Classifier::Classification?) -> void } -> void
+      def on_classified: () { (untyped, Classifier::Classification?) -> void } -> void
+
+      # : (Hash[String, String]) -> Array[String]
+      def remember_broken: (Hash[String, String]) -> Array[String]
+
+      # : () -> Array[String]
+      def broken_files: () -> Array[String]
+
+      # : () -> Array[Hash[Symbol, untyped]]
+      def broken_entries: () -> Array[Hash[Symbol, untyped]]
+
+      # : () -> bool
+      def compiles?: () -> bool
+
+      # : (Watcher::Event) -> void
+      def handle_event: (Watcher::Event) -> void
+
+      private
+
+      # : (Watcher::Event) -> void
+      def handle_removed: (Watcher::Event) -> void
+
+      # : (Watcher::Event) -> void
+      def handle_added: (Watcher::Event) -> void
+
+      # : (Watcher::Event) -> void
+      def handle_changed: (Watcher::Event) -> void
+
+      # : (Watcher::Event, Classifier::Classification) -> void
+      def handle_parse_error: (Watcher::Event, Classifier::Classification) -> void
+
+      # : (Watcher::Event, Classifier::Classification) -> void
+      def handle_content_change: (Watcher::Event, Classifier::Classification) -> void
+
+      # : (Herb::Dev::_Compiler, Watcher::Event) -> untyped
+      def compile: (Herb::Dev::_Compiler, Watcher::Event) -> untyped
+
+      # : (StandardError) -> untyped
+      def failure: (StandardError) -> untyped
+
+      # : (String, Watcher::Event, untyped, Classifier::Classification) -> Hash[Symbol, untyped]
+      def schema_for: (String, Watcher::Event, untyped, Classifier::Classification) -> Hash[Symbol, untyped]
+
+      # : (String, Classifier::Classification, untyped) -> Hash[Symbol, untyped]
+      def invalidate_for: (String, Classifier::Classification, untyped) -> Hash[Symbol, untyped]
+
+      # : (String, Classifier::Classification, untyped) -> Symbol
+      def scope_for: (String, Classifier::Classification, untyped) -> Symbol
+
+      # : (untyped) -> untyped
+      def states_of: (untyped) -> untyped
+
+      # : (String, untyped, Classifier::Classification) -> Hash[String, untyped]?
+      def remap_for: (String, untyped, Classifier::Classification) -> Hash[String, untyped]?
+
+      # : (String, untyped) -> Array[String]?
+      def changed_statics_for: (String, untyped) -> Array[String]?
+
+      # : (String, untyped) -> void
+      def remember: (String, untyped) -> void
+
+      # : (String, Array[Hash[Symbol, untyped]]) -> void
+      def record_diagnostics: (String, Array[Hash[Symbol, untyped]]) -> void
+
+      # : (untyped) -> Array[Hash[Symbol, untyped]]
+      def diagnostics_of: (untyped) -> Array[Hash[Symbol, untyped]]
+
+      # : (Watcher::Event, Classifier::Classification) -> void
+      def handle_without_compiler: (Watcher::Event, Classifier::Classification) -> void
+
+      # : (Hash[Symbol, untyped]) -> void
+      def broadcast: (Hash[Symbol, untyped]) -> void
+
+      # : (Watcher::Event, Classifier::Classification?) -> void
+      def notify: (Watcher::Event, Classifier::Classification?) -> void
+    end
+  end
+end

data/sig/herb/dev/protocol.rbs

@@ -0,0 +1,78 @@
+# Generated from lib/herb/dev/protocol.rb with RBS::Inline
+
+module Herb
+  module Dev
+    # Builds the messages the dev server broadcasts, and nothing else.
+    #
+    # Everything here is a pure function from what the pipeline knows to a Hash the socket
+    # writes out, so the whole protocol is testable without a connection.
+    #
+    # A `schema` message always carries `diagnostics`, and an empty array means the file is
+    # clean now. That is the whole error lifecycle. There is no separate message for a file
+    # being fixed.
+    module Protocol
+      MAX_REMAP_OPERATIONS: Integer
+
+      NULLING_TYPES: Array[Symbol]
+
+      REPLAYED_TYPES: Array[Symbol]
+
+      # : (file: String, mode: Symbol?, from: String?, to: String?, ?manifest: Hash[String, untyped]?, ?static_markup: String?, ?statics: Hash[String, String]?, ?changed_statics: Array[String]?, ?remap: Hash[String, untyped]?, ?diagnostics: Array[Hash[Symbol, untyped]], ?source: String?) -> Hash[Symbol, untyped]
+      def self.schema: (file: String, mode: Symbol?, from: String?, to: String?, ?manifest: Hash[String, untyped]?, ?static_markup: String?, ?statics: Hash[String, String]?, ?changed_statics: Array[String]?, ?remap: Hash[String, untyped]?, ?diagnostics: Array[Hash[Symbol, untyped]], ?source: String?) -> Hash[Symbol, untyped]
+
+      # : (project: String?, ?broken_files: Array[String]) -> Hash[Symbol, untyped]
+      def self.welcome: (project: String?, ?broken_files: Array[String]) -> Hash[Symbol, untyped]
+
+      # : (file: String, version: String?, node_path: Array[Integer], scope: Symbol) -> Hash[Symbol, untyped]
+      def self.invalidate: (file: String, version: String?, node_path: Array[Integer], scope: Symbol) -> Hash[Symbol, untyped]
+
+      # : (kind: Symbol, file: String) -> Hash[Symbol, untyped]
+      def self.asset: (kind: Symbol, file: String) -> Hash[Symbol, untyped]
+
+      # : (file: String, source: String, errors: Array[untyped]) -> Hash[Symbol, untyped]
+      def self.error: (file: String, source: String, errors: Array[untyped]) -> Hash[Symbol, untyped]
+
+      # : (String, Array[untyped]) -> Array[Hash[Symbol, untyped]]
+      def self.error_entries: (String, Array[untyped]) -> Array[Hash[Symbol, untyped]]
+
+      # : (file: String, ?source: String?, ?errors: Array[untyped]?, ?diagnostics: Array[untyped]?) -> Hash[Symbol, untyped]
+      def self.broken: (file: String, ?source: String?, ?errors: Array[untyped]?, ?diagnostics: Array[untyped]?) -> Hash[Symbol, untyped]
+
+      # : (Array[Hash[Symbol, untyped]], Array[Hash[Symbol, untyped]], Array[Herb::Diff::Operation]) -> Hash[String, untyped]?
+      def self.remap: (Array[Hash[Symbol, untyped]], Array[Hash[Symbol, untyped]], Array[Herb::Diff::Operation]) -> Hash[String, untyped]?
+
+      # : (Hash[Symbol, untyped], Array[Hash[Symbol, untyped]], Hash[String, Hash[Symbol, untyped]], Array[Herb::Diff::Operation], Array[Herb::Diff::Operation], Array[Herb::Diff::Operation]) -> Integer?
+      def self.target_for: (Hash[Symbol, untyped], Array[Hash[Symbol, untyped]], Hash[String, Hash[Symbol, untyped]], Array[Herb::Diff::Operation], Array[Herb::Diff::Operation], Array[Herb::Diff::Operation]) -> Integer?
+
+      # : (Array[Integer], Array[Herb::Diff::Operation], Array[Herb::Diff::Operation], Array[Herb::Diff::Operation]) -> Array[Integer]?
+      def self.replay: (Array[Integer], Array[Herb::Diff::Operation], Array[Herb::Diff::Operation], Array[Herb::Diff::Operation]) -> Array[Integer]?
+
+      # : (Array[Herb::Diff::Operation]) -> bool
+      def self.replayable?: (Array[Herb::Diff::Operation]) -> bool
+
+      # : (Hash[Symbol, untyped], Hash[Symbol, untyped], Array[Integer]) -> bool
+      def self.counterpart?: (Hash[Symbol, untyped], Hash[Symbol, untyped], Array[Integer]) -> bool
+
+      # : (Array[Herb::Diff::Operation], Array[Integer]) -> bool
+      def self.nulled?: (Array[Herb::Diff::Operation], Array[Integer]) -> bool
+
+      # : (Array[Integer], Array[Integer]) -> bool
+      def self.prefix?: (Array[Integer], Array[Integer]) -> bool
+
+      # : (Array[Integer], Array[Integer]) -> bool
+      def self.sibling_before?: (Array[Integer], Array[Integer]) -> bool
+
+      # : (Array[Integer], Array[Integer]) -> bool
+      def self.sibling_at_or_before?: (Array[Integer], Array[Integer]) -> bool
+
+      # : (Array[Integer], Array[Integer]) -> bool
+      def self.same_parent?: (Array[Integer], Array[Integer]) -> bool
+
+      # : (Array[Integer], Array[Integer]) -> Integer
+      def self.sibling_index: (Array[Integer], Array[Integer]) -> Integer
+
+      # : (Array[Integer]) -> Integer
+      def self.operation_index: (Array[Integer]) -> Integer
+    end
+  end
+end

data/sig/herb/dev/runner.rbs

@@ -7,53 +7,91 @@ module Herb
 
       PATCHABLE_TYPES: Array[String]
 
-      def self.can_patch?: (untyped operations) -> untyped
+      # : (Array[Herb::Diff::Operation]) -> bool
+      def self.can_patch?: (Array[Herb::Diff::Operation]) -> bool
 
-      CLEAR_SCREEN: ::String
+      CLEAR_SCREEN: String
 
-      HIDE_CURSOR: ::String
+      HIDE_CURSOR: String
 
-      SHOW_CURSOR: ::String
+      SHOW_CURSOR: String
 
-      def initialize: (?path: untyped, ?cli: untyped) -> untyped
+      # : (?path: String) -> void
+      def initialize: (?path: String) -> void
 
-      def run: () -> untyped
+      # : () -> void
+      def run: () -> void
 
-      def stop: () -> untyped
+      # : () -> void
+      def stop: () -> void
 
-      def restart: () -> untyped
+      # : () -> void
+      def restart: () -> void
 
-      def status: () -> untyped
+      # : () -> void
+      def status: () -> void
 
       private
 
-      def pluralize: (untyped count, untyped word) -> untyped
+      # : () -> bool
+      def interactive?: () -> bool
 
-      def require_cruise: () -> untyped
+      # : (String) -> void
+      def terminal: (String) -> void
 
-      def check_existing_server: (untyped expanded_path) -> untyped
+      # : (String, Array[Herb::Diagnostic], String) -> void
+      def print_diagnostics: (String, Array[Herb::Diagnostic], String) -> void
 
-      def find_port: () -> untyped
+      # : (Integer, String) -> String
+      def pluralize: (Integer, String) -> String
 
-      def print_header: (untyped config, untyped expanded_path) -> untyped
+      # : () -> void
+      def require_cruise: () -> void
 
-      def index_files: (untyped config, untyped path) -> untyped
+      # : (String) -> void
+      def check_existing_server: (String) -> void
 
-      def watch_files: (untyped config, untyped expanded_path, untyped websocket, untyped file_states) -> untyped
+      # : () -> Integer
+      def find_port: () -> Integer
 
-      def handle_file_change: (untyped file_path, untyped relative_path, untyped file_states, untyped errored_files, untyped websocket, untyped timestamp, untyped display_path) -> untyped
+      # : (Herb::Configuration, String) -> void
+      def print_header: (Herb::Configuration, String) -> void
 
-      def broadcast_errors: (untyped file_path, untyped relative_path, untyped current_parse, untyped previous_content, untyped errored_files, untyped websocket, untyped timestamp, untyped display_path) -> untyped
+      # : (Watcher, Pipeline) -> Array[String]
+      def index_files: (Watcher, Pipeline) -> Array[String]
 
-      def broadcast_fixed: (untyped file_path, untyped relative_path, untyped current_content, untyped file_states, untyped websocket, untyped timestamp, untyped display_path) -> untyped
+      # : (Integer) -> String
+      def broken_summary: (Integer) -> String
 
-      def handle_diff: (untyped file_path, untyped relative_path, untyped current_content, untyped previous_content, untyped file_states, untyped websocket, untyped timestamp, untyped display_path) -> untyped
+      # : () -> Thread?
+      def watch_stdin: () -> Thread?
 
-      def print_diff_summary: (untyped operations, untyped can_patch, untyped websocket, untyped timestamp, untyped display_path) -> untyped
+      # : () -> void
+      def announce_first_change: () -> void
 
-      def print_diff_node: (untyped indent, untyped sign, untyped color, untyped node, untyped _type) -> untyped
+      # : (Symbol, Integer) -> void
+      def paint_client: (Symbol, Integer) -> void
 
-      def extract_node_value: (untyped node) -> untyped
+      # : (Watcher::Event, Classifier::Classification?) -> void
+      def paint: (Watcher::Event, Classifier::Classification?) -> void
+
+      # : (Watcher::Event, Classifier::Classification, String, String) -> void
+      def paint_change: (Watcher::Event, Classifier::Classification, String, String) -> void
+
+      # : (Watcher::Event, Classifier::Classification) -> Array[Herb::Errors::Error]
+      def new_errors: (Watcher::Event, Classifier::Classification) -> Array[Herb::Errors::Error]
+
+      # : (Watcher::Event, String, String) -> void
+      def paint_cleared: (Watcher::Event, String, String) -> void
+
+      # : (Classifier::Classification, String, String) -> void
+      def print_diff_summary: (Classifier::Classification, String, String) -> void
+
+      # : (String, String, Integer, Herb::AST::Node, String) -> void
+      def print_diff_node: (String, String, Integer, Herb::AST::Node, String) -> void
+
+      # : (Herb::AST::Node?) -> String?
+      def extract_node_value: (Herb::AST::Node?) -> String?
     end
   end
 end

data/sig/herb/dev/server.rbs

@@ -3,48 +3,75 @@
 module Herb
   module Dev
     class Server
-      DEFAULT_PORT: ::Integer
+      DEFAULT_PORT: Integer
 
-      HANDSHAKE_TIMEOUT: ::Integer
+      HANDSHAKE_TIMEOUT: Integer
 
-      attr_reader port: untyped
+      ROLES: Array[Symbol]
 
-      attr_reader project_path: untyped
+      class Client < Struct[untyped]
+        attr_accessor socket(): untyped
 
-      class Client < Data
-        attr_reader socket(): untyped
+        attr_accessor version(): untyped
 
-        attr_reader version(): untyped
+        attr_accessor mutex(): untyped
 
-        attr_reader mutex(): untyped
+        attr_accessor role(): untyped
 
-        def self.new: (untyped socket, untyped version, untyped mutex) -> instance
-                    | (socket: untyped, version: untyped, mutex: untyped) -> instance
+        def self.new: (?socket: untyped, ?version: untyped, ?mutex: untyped, ?role: untyped) -> instance
+                    | ({ ?socket: untyped, ?version: untyped, ?mutex: untyped, ?role: untyped }) -> instance
+      end
 
-        def self.members: () -> [ :socket, :version, :mutex ]
+      attr_reader port: Integer
 
-        def members: () -> [ :socket, :version, :mutex ]
-      end
+      attr_reader project_path: String?
+
+      # : (?port: Integer, ?project_path: String?, ?kind: String) -> void
+      def initialize: (?port: Integer, ?project_path: String?, ?kind: String) -> void
+
+      # : () -> void
+      def start: () -> void
 
-      def initialize: (?port: untyped, ?project_path: untyped) -> untyped
+      # : () -> void
+      def stop: () -> void
 
-      def start: () -> untyped
+      # : (Hash[Symbol, untyped] | String, ?to: Symbol) -> void
+      def broadcast: (Hash[Symbol, untyped] | String, ?to: Symbol) -> void
 
-      def stop: () -> untyped
+      # : () { (Symbol, Integer) -> void } -> void
+      def on_client: () { (Symbol, Integer) -> void } -> void
 
-      def broadcast: (untyped message) -> untyped
+      # : () { () -> Array[Hash[Symbol, untyped]] } -> void
+      def on_welcome: () { () -> Array[Hash[Symbol, untyped]] } -> void
 
-      def client_count: () -> untyped
+      # : (Client) -> void
+      def register: (Client) -> void
 
-      def self.port_available?: (untyped port) -> untyped
+      # : (untyped) -> void
+      def unregister: (untyped) -> void
 
-      def self.find_available_port: (?untyped starting_port) -> untyped
+      # : () -> Integer
+      def client_count: () -> Integer
+
+      # : (Integer) -> bool
+      def self.port_available?: (Integer) -> bool
+
+      # : (?Integer) -> Integer?
+      def self.find_available_port: (?Integer) -> Integer?
+
+      # : (Client, String) -> void
+      def handle_text_frame: (Client, String) -> void
 
       private
 
-      def safely_close: (untyped resource) -> untyped
+      # : () -> Array[Hash[Symbol, untyped]]
+      def broken_entries: () -> Array[Hash[Symbol, untyped]]
+
+      # : (untyped) -> void
+      def safely_close: (untyped) -> void
 
-      def handle_connection: (untyped socket) -> untyped
+      # : (untyped) -> void
+      def handle_connection: (untyped) -> void
     end
   end
 end