herb 0.10.4-x86_64-linux-gnu → 0.11.1-x86_64-linux-gnu

data/sig/herb/dev/server_entry.rbs

@@ -3,49 +3,74 @@
 module Herb
   module Dev
     class ServerEntry
-      SERVERS_DIR: untyped
+      SERVERS_DIR: String
 
-      REQUIRED_KEYS: untyped
+      REQUIRED_KEYS: Array[String]
 
-      attr_reader pid: untyped
+      KINDS: Array[String]
 
-      attr_reader port: untyped
+      attr_reader pid: Integer
 
-      attr_reader project: untyped
+      attr_reader port: Integer
 
-      attr_reader started_at: untyped
+      attr_reader project: String?
 
-      def initialize: (pid: untyped, port: untyped, project: untyped, ?started_at: untyped) -> untyped
+      attr_reader started_at: String
 
-      def save: () -> untyped
+      attr_reader kind: String
 
-      def remove: () -> untyped
+      # : (pid: Integer, port: Integer, project: String?, ?started_at: String, ?kind: String) -> void
+      def initialize: (pid: Integer, port: Integer, project: String?, ?started_at: String, ?kind: String) -> void
 
-      def alive?: () -> untyped
+      # : () -> bool
+      def embedded?: () -> bool
 
-      def to_hash: () -> untyped
+      # : () -> void
+      def save: () -> void
 
-      def to_json: (*untyped) -> untyped
+      # : () -> void
+      def remove: () -> void
 
-      def project_name: () -> untyped
+      # : () -> bool
+      def alive?: () -> bool
 
-      def stop!: () -> untyped
+      # : () -> Hash[Symbol, untyped]
+      def to_hash: () -> Hash[Symbol, untyped]
 
-      def self.all: () -> untyped
+      # : (*untyped) -> String
+      def to_json: (*untyped) -> String
 
-      def self.find_by_port: (untyped port) -> untyped
+      # : () -> String
+      def project_name: () -> String
 
-      def self.find_by_project: (untyped project_path) -> untyped
+      # : () -> bool
+      def stop!: () -> bool
 
-      def self.stop_all: () -> untyped
+      # : () -> Array[ServerEntry]
+      def self.all: () -> Array[ServerEntry]
 
-      def self.process_alive?: (untyped pid) -> untyped
+      # : (Integer) -> ServerEntry?
+      def self.find_by_port: (Integer) -> ServerEntry?
 
-      private def self.load_file: (untyped path) -> untyped
+      # : (String) -> ServerEntry?
+      def self.find_by_project: (String) -> ServerEntry?
+
+      # : (?String?) -> Integer?
+      def self.port_for: (?String?) -> Integer?
+
+      # : () -> void
+      def self.stop_all: () -> void
+
+      # : (Integer?) -> bool
+      def self.process_alive?: (Integer?) -> bool
+
+      # : (String) -> ServerEntry?
+      private def self.load_file: (String) -> ServerEntry?
 
       private
 
-      def file_path: () -> untyped
+      # : () -> String
+      def file_path: () -> String
     end
   end
 end

data/sig/herb/dev/watcher.rbs

@@ -0,0 +1,84 @@
+# Generated from lib/herb/dev/watcher.rb with RBS::Inline
+
+module Herb
+  module Dev
+    # Watches a project's templates and says which one changed.
+    #
+    # Cruise reports raw filesystem events, and most of them are noise. This keeps the last
+    # content it saw for every template, filters events through the project's include and
+    # exclude patterns, and emits one normalized event per change that actually changed
+    # something, carrying both the previous and the current source so nothing downstream has
+    # to read the file again.
+    #
+    #     watcher = Herb::Dev::Watcher.new(config: config, root: root) do |event|
+    #       pipeline.handle_event(event)
+    #     end
+    #
+    #     watcher.run    # blocks, for the CLI
+    #     watcher.spawn  # returns a Thread, for an embedded host
+    class Watcher
+      KINDS: Array[String]
+
+      class Event < Data
+        attr_reader kind(): Symbol
+
+        attr_reader path(): String
+
+        attr_reader relative_path(): String
+
+        attr_reader previous(): String?
+
+        attr_reader current(): String?
+
+        def self.new: (Symbol kind, String path, String relative_path, String? previous, String? current) -> instance
+                    | (kind: Symbol, path: String, relative_path: String, previous: String?, current: String?) -> instance
+
+        def self.members: () -> [ :kind, :path, :relative_path, :previous, :current ]
+
+        def members: () -> [ :kind, :path, :relative_path, :previous, :current ]
+      end
+
+      attr_reader file_states: Hash[String, String]
+
+      attr_reader watch_paths: Array[String]
+
+      # : (config: Herb::Configuration, root: String, ?watch_paths: Array[String]?) { (Event) -> void } -> void
+      def initialize: (config: Herb::Configuration, root: String, ?watch_paths: Array[String]?) { (Event) -> void } -> void
+
+      # : (?String) -> Integer
+      def index: (?String) -> Integer
+
+      # : () -> Hash[String, String]
+      def sources: () -> Hash[String, String]
+
+      # : () -> void
+      def run: () -> void
+
+      # : () -> Thread
+      def spawn: () -> Thread
+
+      # : () -> void
+      def stop: () -> void
+
+      private
+
+      # : (Array[String]?) -> Array[String]
+      def resolve_watch_paths: (Array[String]?) -> Array[String]
+
+      # : (Array[String]) -> Array[String]
+      def asset_watch_paths: (Array[String]) -> Array[String]
+
+      # : (String) -> String
+      def relative_for: (String) -> String
+
+      # : (Cruise::Event) -> void
+      def handle: (Cruise::Event) -> void
+
+      # : (String, String) -> void
+      def handle_asset: (String, String) -> void
+
+      # : (String, String, String) -> Event?
+      def normalize: (String, String, String) -> Event?
+    end
+  end
+end

data/sig/herb/dev.rbs

@@ -0,0 +1,58 @@
+# Generated from lib/herb/dev.rb with RBS::Inline
+
+module Herb
+  # The development server: a file watcher, a websocket, and the pipeline between them.
+  #
+  # The dev server never compiles a template itself, because slot identity depends on the
+  # visitor stack the application compiles with, and only the application knows that stack.
+  # A host that does know it registers a compiler here:
+  #
+  #     Herb::Dev.compiler = ->(source, relative_path) { ... }
+  #
+  # The compiler returns nil for a file it cannot compile at all, and otherwise an object
+  # answering `mode`, `manifest`, `version`, `slot_entries`, `statics`, `static_markup` and
+  # `diagnostics`. Without one, the pipeline still classifies changes and tells browsers to
+  # fetch, so everything degrades instead of breaking.
+  module Dev
+    interface _Compiler
+      def call: (String source, String relative_path) -> _CompiledSchema?
+    end
+
+    interface _CompiledSchema
+      def mode: () -> Symbol?
+
+      def manifest: () -> Hash[String, untyped]?
+
+      def version: () -> String?
+
+      def slot_entries: () -> Array[Hash[Symbol, untyped]]?
+
+      def statics: () -> Hash[String, String]?
+
+      def static_markup: () -> String?
+
+      def diagnostics: () -> Array[untyped]?
+    end
+
+    attr_accessor self.compiler: _Compiler?
+
+    # Starts the watcher and the websocket server inside the current process, for a host
+    # that already runs the application, like a Rails server in development. Everything a
+    # start would collide with makes it a no-op instead of an error, so a host can call it
+    # unconditionally:
+    #
+    #     Rails.application.server { Herb::Dev.boot(Rails.root.to_s) }
+    #
+    # : (String, ?watch_paths: Array[String]?, ?environment: String?, ?logger: ^(String) -> void) -> Embedded?
+    def self.boot: (String, ?watch_paths: Array[String]?, ?environment: String?, ?logger: ^(String) -> void) -> Embedded?
+
+    # : (Watcher::Event, Classifier::Classification?) -> String?
+    def self.activity_line: (Watcher::Event, Classifier::Classification?) -> String?
+
+    # : () -> Embedded?
+    def self.booted: () -> Embedded?
+
+    # : () -> void
+    def self.shutdown: () -> void
+  end
+end

data/sig/herb/diagnostic/formatter.rbs

@@ -0,0 +1,28 @@
+# Generated from lib/herb/diagnostic/formatter.rb with RBS::Inline
+
+module Herb
+  class Diagnostic
+    class Formatter
+      attr_reader source: String
+
+      attr_reader filename: String | Pathname
+
+      # : (String, Array[Herb::Diagnostic], **untyped) -> void
+      def initialize: (String, Array[Herb::Diagnostic], **untyped) -> void
+
+      # : () -> String
+      def summary: () -> String
+
+      # : (?highlight: bool) -> String
+      def format_all: (?highlight: bool) -> String
+
+      private
+
+      def format_diagnostic: (untyped diagnostic) -> untyped
+
+      def format_source_context: (untyped diagnostic) -> untyped
+
+      def format_details: (untyped diagnostic) -> untyped
+    end
+  end
+end

data/sig/herb/diagnostic.rbs

@@ -0,0 +1,88 @@
+# Generated from lib/herb/diagnostic.rb with RBS::Inline
+
+module Herb
+  class Diagnostic
+    UNKNOWN_ORIGIN: String
+
+    attr_reader template: String
+
+    attr_reader message: String
+
+    attr_reader node: String?
+
+    attr_reader code: String?
+
+    attr_reader severity: Symbol?
+
+    attr_reader kind: Symbol
+
+    attr_reader origin: String
+
+    attr_reader location: Herb::Location?
+
+    attr_reader suggestion: String?
+
+    attr_reader description: String?
+
+    attr_reader docs_url: String?
+
+    attr_reader value: String?
+
+    attr_reader overlay: Symbol?
+
+    attr_reader phase: Symbol
+
+    attr_reader data: Hash[Symbol, untyped]
+
+    attr_reader error_class: Class?
+
+    # : (template: String, message: String, ?severity: Symbol?, ?kind: Symbol, ?origin: String, ?node: String?, ?code: String?, ?location: Herb::Location?, ?suggestion: String?, ?description: String?, ?docs_url: String?, ?value: String?, ?overlay: Symbol?, ?phase: Symbol, ?data: Hash[Symbol, untyped], ?error_class: Class?) -> void
+    def initialize: (template: String, message: String, ?severity: Symbol?, ?kind: Symbol, ?origin: String, ?node: String?, ?code: String?, ?location: Herb::Location?, ?suggestion: String?, ?description: String?, ?docs_url: String?, ?value: String?, ?overlay: Symbol?, ?phase: Symbol, ?data: Hash[Symbol, untyped], ?error_class: Class?) -> void
+
+    # : (Array[Herb::Errors::Error], template: String, ?origin: String) -> Array[Diagnostic]
+    def self.from_errors: (Array[Herb::Errors::Error], template: String, ?origin: String) -> Array[Diagnostic]
+
+    # : (String, Hash[Symbol, untyped]) -> Diagnostic
+    def self.from_compiled: (String, Hash[Symbol, untyped]) -> Diagnostic
+
+    # : () -> bool
+    def error?: () -> bool
+
+    # : () -> bool
+    def warning?: () -> bool
+
+    # : () -> bool
+    def info?: () -> bool
+
+    # : () -> bool
+    def hint?: () -> bool
+
+    # : (String?) -> Diagnostic
+    def with_node: (String?) -> Diagnostic
+
+    # : () -> Array[untyped]
+    def key: () -> Array[untyped]
+
+    # : () -> Hash[Symbol, untyped]
+    def to_h: () -> Hash[Symbol, untyped]
+
+    alias to_hash to_h
+
+    # : (?String?) -> String
+    def to_ruby: (?String?) -> String
+
+    # : (?untyped) -> String
+    def to_json: (?untyped) -> String
+
+    # : () -> String
+    def to_s: () -> String
+
+    private
+
+    # : (Herb::Location) -> Hash[Symbol, untyped]
+    def serialized_location: (Herb::Location) -> Hash[Symbol, untyped]
+
+    # : (Herb::Position) -> Hash[Symbol, Integer]
+    def serialized_position: (Herb::Position) -> Hash[Symbol, Integer]
+  end
+end

data/sig/herb/diff/operation.rbs

@@ -0,0 +1,36 @@
+# Generated from lib/herb/diff/operation.rb with RBS::Inline
+
+module Herb
+  module Diff
+    class Operation < Data
+      attr_reader type(): Symbol
+
+      attr_reader path(): Array[Integer]
+
+      attr_reader old_node(): Herb::AST::Node?
+
+      attr_reader new_node(): Herb::AST::Node?
+
+      attr_reader old_index(): Integer
+
+      attr_reader new_index(): Integer
+
+      def self.new: (Symbol type, Array[Integer] path, Herb::AST::Node? old_node, Herb::AST::Node? new_node, Integer old_index, Integer new_index) -> instance
+                  | (type: Symbol, path: Array[Integer], old_node: Herb::AST::Node?, new_node: Herb::AST::Node?, old_index: Integer, new_index: Integer) -> instance
+
+      def self.members: () -> [ :type, :path, :old_node, :new_node, :old_index, :new_index ]
+
+      def members: () -> [ :type, :path, :old_node, :new_node, :old_index, :new_index ]
+    end
+
+    class Operation
+      # : () -> Hash[Symbol, untyped]
+      def to_hash: () -> Hash[Symbol, untyped]
+
+      alias to_h to_hash
+
+      # : () -> String
+      def inspect: () -> String
+    end
+  end
+end

data/sig/herb/diff/result.rbs

@@ -0,0 +1,36 @@
+# Generated from lib/herb/diff/result.rb with RBS::Inline
+
+module Herb
+  module Diff
+    class Result
+      include Enumerable[Herb::Diff::Operation]
+
+      attr_reader operations: Array[Herb::Diff::Operation]
+
+      # : (bool, Array[Herb::Diff::Operation]) -> void
+      def initialize: (bool, Array[Herb::Diff::Operation]) -> void
+
+      # : () { (Herb::Diff::Operation) -> void } -> void
+      # : () -> Enumerator[Herb::Diff::Operation, void]
+      def each: () { (Herb::Diff::Operation) -> void } -> void
+              | () -> Enumerator[Herb::Diff::Operation, void]
+
+      # : () -> bool
+      def identical?: () -> bool
+
+      # : () -> Integer
+      def operation_count: () -> Integer
+
+      # : () -> bool
+      def changed?: () -> bool
+
+      # : () -> Hash[Symbol, untyped]
+      def to_hash: () -> Hash[Symbol, untyped]
+
+      alias to_h to_hash
+
+      # : () -> String
+      def inspect: () -> String
+    end
+  end
+end

data/sig/herb/diff.rbs

@@ -0,0 +1,6 @@
+# Generated from lib/herb/diff.rb with RBS::Inline
+
+module Herb
+  module Diff
+  end
+end

data/sig/herb/engine/collector.rbs

@@ -0,0 +1,48 @@
+# Generated from lib/herb/engine/collector.rb with RBS::Inline
+
+module Herb
+  class Engine
+    # What a set of templates says about itself, gathered without rendering any of them.
+    #
+    # Compiling a template settles things a host wants to know before a request arrives. A
+    # collector compiles files for that and nothing else, and a subclass says what to keep from
+    # each one. Which files to give it, and where what it gathers goes, is the job of whatever
+    # integrates Herb with a framework.
+    #
+    # A file that will not compile is recorded in #failures and the run carries on, so one broken
+    # template does not cost a host the rest of them.
+    class Collector
+      class Failure < Data
+        attr_reader file(): untyped
+
+        attr_reader error(): untyped
+
+        def self.new: (untyped file, untyped error) -> instance
+                    | (file: untyped, error: untyped) -> instance
+
+        def self.members: () -> [ :file, :error ]
+
+        def members: () -> [ :file, :error ]
+      end
+
+      attr_reader failures: Array[Failure]
+
+      # : (?project_path: (String | Pathname)?, **untyped) -> void
+      def initialize: (?project_path: (String | Pathname)?, **untyped) -> void
+
+      # : ((String | Pathname), ?String?) -> untyped
+      def add: (String | Pathname, ?String?) -> untyped
+
+      # : ((String | Pathname), ?String) -> Array[untyped]
+      def add_all: (String | Pathname, ?String) -> Array[untyped]
+
+      private
+
+      # : [T] ((String | Pathname), String?, untyped) { (untyped) -> T? } -> T?
+      def compile: [T] (String | Pathname, String?, untyped) { (untyped) -> T? } -> T?
+
+      # : ((String | Pathname), untyped) -> Hash[Symbol, untyped]
+      def engine_options: (String | Pathname, untyped) -> Hash[Symbol, untyped]
+    end
+  end
+end

data/sig/herb/engine/compiler.rbs

@@ -3,22 +3,22 @@
 module Herb
   class Engine
     class Compiler < ::Herb::Visitor
-      EXPRESSION_TOKEN_TYPES: untyped
+      PADDING_NEWLINES: Array[String]
 
-      TRAILING_WHITESPACE: ::Regexp
+      EXPRESSION_TOKEN_TYPES: Array[Symbol]
 
-      TRAILING_INDENTATION: ::Regexp
+      HORIZONTAL_SPACE: Array[String]
 
-      TRAILING_INDENTATION_CAPTURE: ::Regexp
-
-      WHITESPACE_ONLY: ::Regexp
-
-      WHITESPACE_ONLY_CAPTURE: ::Regexp
+      RAW_TEXT_ELEMENTS: Array[String]
 
       attr_reader tokens: untyped
 
       def initialize: (untyped engine, ?untyped options) -> untyped
 
+      def optimized_tokens: () -> untyped
+
+      def static_template_text: () -> untyped
+
       def generate_output: () -> untyped
 
       def visit_document_node: (untyped node) -> untyped
@@ -57,10 +57,16 @@ module Herb
 
       def visit_xml_declaration_node: (untyped node) -> untyped
 
+      def visit_xml_processing_instruction_node: (untyped node) -> untyped
+
       def visit_cdata_node: (untyped node) -> untyped
 
       def visit_erb_content_node: (untyped node) -> untyped
 
+      def visit_erb_comment_node: (untyped node) -> untyped
+
+      def visit_erb_strict_locals_node: (untyped node) -> untyped
+
       def visit_erb_control_node: (untyped node) ?{ (?) -> untyped } -> untyped
 
       def visit_erb_if_node: (untyped node) -> untyped
@@ -95,13 +101,21 @@ module Herb
 
       def visit_erb_block_node: (untyped node) -> untyped
 
+      def visit_erb_iteration_block_node: (untyped node) -> untyped
+
+      def visit_erb_render_node: (untyped node) -> untyped
+
       def visit_erb_block_end_node: (untyped node, ?escaped: untyped) -> untyped
 
-      def visit_erb_control_with_parts: (untyped node, *untyped parts) -> untyped
+      def visit_erb_case_parts: (untyped node) -> untyped
+
+      def visit_erb_control_with_parts: (untyped node, *untyped parts) ?{ (?) -> untyped } -> untyped
 
       private
 
-      def check_for_escaped_erb_tag!: (untyped opening) -> untyped
+      def add_escaped_erb_tag: (untyped node) -> untyped
+
+      def add_escaped_erb_block: (untyped node) -> untyped
 
       def current_context: () -> untyped
 
@@ -109,14 +123,17 @@ module Herb
 
       def pop_context: () -> untyped
 
-      # : (untyped node) { () -> untyped } -> untyped
-      def with_element_context: (untyped node) { () -> untyped } -> untyped
+      # : (untyped node) { (String?) -> untyped } -> untyped
+      def with_element_context: (untyped node) { (String?) -> untyped } -> untyped
 
       def process_erb_tag: (untyped node, ?skip_comment_check: untyped) -> untyped
 
-      def add_text: (untyped text) -> untyped
+      # : (untyped, ?extra: Integer) -> void
+      def keep_span_line_count: (untyped, ?extra: Integer) -> void
+
+      def keep_line_count: (untyped node, ?extra: untyped, ?at: untyped, ?absorbed: untyped, ?raw: untyped) -> untyped
 
-      def add_whitespace: (untyped whitespace) -> untyped
+      def add_text: (untyped text) -> untyped
 
       def add_code: (untyped code) -> untyped
 
@@ -126,17 +143,9 @@ module Herb
 
       def optimize_tokens: (untyped tokens) -> untyped
 
-      def compact_whitespace_tokens: (untyped tokens) -> untyped
-
-      def adjacent_whitespace?: (untyped tokens, untyped index) -> untyped
-
-      def trailing_whitespace?: (untyped token) -> untyped
-
-      def leading_whitespace?: (untyped token) -> untyped
+      def padding_newlines: (untyped count) -> untyped
 
-      def whitespace_before_code_sequence?: (untyped tokens, untyped current_index) -> untyped
-
-      def find_token_before_code_sequence: (untyped tokens, untyped whitespace_index) -> untyped
+      def optimize_tokens_with_padding: (untyped tokens) -> untyped
 
       def process_erb_output: (untyped node, untyped opening, untyped code) -> untyped
 
@@ -148,6 +157,21 @@ module Herb
 
       def add_expression_with_escaping: (untyped code, untyped should_escape) -> untyped
 
+      # : (String) -> Integer
+      def trailing_space_length: (String) -> Integer
+
+      # : (String) -> String
+      def trailing_spaces: (String) -> String
+
+      # : (String) -> void
+      def remove_trailing_spaces!: (String) -> void
+
+      # : (String) -> bool
+      def whitespace_only?: (String) -> bool
+
+      # : (String) -> bool
+      def trailing_indentation?: (String) -> bool
+
       def at_line_start?: () -> untyped
 
       def preceding_token_ends_with_newline?: () -> untyped
@@ -156,16 +180,42 @@ module Herb
 
       def right_trim?: (untyped node) -> untyped
 
+      def preceded_by_whitespace?: () -> untyped
+
+      def emits_nothing?: (untyped token) -> untyped
+
       def last_text_token: () -> untyped
 
       def extract_leading_space: () -> untyped
 
       def leading_space_follows_newline?: () -> untyped
 
+      def preceding_token_value_ends_with_newline?: () -> untyped
+
       def extract_and_remove_leading_space!: () -> untyped
 
       def apply_trim: (untyped node, untyped code) -> untyped
 
+      def continues_into_next_node?: (untyped node) -> untyped
+
+      # : (untyped) -> bool
+      def without_source?: (untyped) -> bool
+
+      # : (bool) -> void
+      def settle_pending_span_extra!: (bool) -> void
+
+      # : (bool) -> void
+      def settle_pending_trim_newline!: (bool) -> void
+
+      # : (Array[untyped]) -> void
+      def skip_case_children: (Array[untyped]) -> void
+
+      # : (untyped) -> bool
+      def follows_trimmed_statement_tag?: (untyped) -> bool
+
+      # : () -> void
+      def drop_pending_trim_newline!: () -> void
+
       def save_pending_leading_whitespace!: (untyped whitespace) -> untyped
 
       def restore_pending_leading_whitespace!: () -> untyped

data/sig/herb/engine/component_tags/constant_resolver.rbs

@@ -0,0 +1,19 @@
+# Generated from lib/herb/engine/component_tags/constant_resolver.rb with RBS::Inline
+
+module Herb
+  class Engine
+    module ComponentTags
+      # Resolves a tag name that is a Ruby constant, so `<Card />` becomes `render Card.new` and
+      # `<Users::Card />` becomes `render Users::Card.new`.
+      class ConstantResolver < Resolver
+        TAG_NAME: ::Regexp
+
+        # : (String) -> bool
+        def handles?: (String) -> bool
+
+        # : (String, Hash[String, String], block: bool) -> String
+        def render_code: (String, Hash[String, String], block: bool) -> String
+      end
+    end
+  end
+end