herb 0.10.4 → 0.11.0

data/sig/herb/engine/slots/visitor.rbs

@@ -0,0 +1,599 @@
+# Generated from lib/herb/engine/slots/visitor.rb with RBS::Inline
+
+module Herb
+  class Engine
+    module Slots
+      # Records where a template's dynamic content ends up, and marks those places in the output so
+      # something outside Ruby can find them again:
+      #
+      #     visitor = Herb::Engine::Slots::Visitor.new
+      #
+      #     Herb::Engine.new(source, visitors: [visitor], filename: "app/views/posts/index.html.erb")
+      #
+      #     visitor.slots
+      #
+      # Templates can also ask for this themselves with a `<%# herb:slots %>` directive, and say who
+      # renders their branches with `<%# herb:slots client %>`. Deciding what that means belongs to
+      # whoever builds the stack, so the directive is only read here:
+      #
+      #     mode = Herb::Engine::Slots::Visitor.directive_mode(source)
+      #     visitors = mode ? [Herb::Engine::Slots::Visitor.new(mode: mode)] : []
+      class Visitor < Herb::Visitor
+        STATE_FAMILIES: Array[Symbol]
+
+        extend Herb::Visitor::Experimental
+
+        include Herb::Visitor::ContextAware
+
+        include Herb::Visitor::Diagnostics
+
+        attr_accessor bufvar: String
+
+        attr_reader markers: Markers
+
+        attr_reader slots: Array[Slot]
+
+        attr_reader states: StateCompiler
+
+        attr_reader document: untyped
+
+        attr_reader warnings: Array[Herb::Warnings::Warning]
+
+        attr_reader static_markup: String?
+
+        attr_reader slot_nodes: Array[untyped]
+
+        SLOTS_DIRECTIVE: Regexp
+
+        MODE_OPTION: Regexp
+
+        MODES: Array[Symbol]
+
+        DELIVERIES: Array[Symbol]
+
+        COVERED: String
+
+        OCCURRENCES: String
+
+        OCCURRENCE: String
+
+        NAME_ATTRIBUTE: String
+
+        KEY_ATTRIBUTE: String
+
+        CAPTURING: Regexp
+
+        LISTENER_ATTRIBUTES: Array[String]
+
+        OPEN_TAG_TYPES: Array[Herb::AST::HTMLOpenTagNode | Herb::AST::ERBOpenTagNode]
+
+        BRANCH_BODY_PROPERTIES: Array[Symbol]
+
+        BRANCH_CONTINUATION_PROPERTIES: Array[Symbol]
+
+        class Slot < Data
+          attr_reader index(): Integer
+
+          attr_reader type(): Symbol
+
+          attr_reader node_path(): Array[Integer]
+
+          attr_reader expression(): String?
+
+          attr_reader attribute(): String?
+
+          attr_reader key_source(): Symbol?
+
+          attr_reader key_expression(): String?
+
+          attr_reader name(): String?
+
+          attr_reader tag(): String?
+
+          attr_reader merged_paths(): Array[Array[Integer]]
+
+          def self.new: (Integer index, Symbol type, Array[Integer] node_path, String? expression, String? attribute, Symbol? key_source, String? key_expression, String? name, String? tag, Array[Array[Integer]] merged_paths) -> instance
+                      | (index: Integer, type: Symbol, node_path: Array[Integer], expression: String?, attribute: String?, key_source: Symbol?, key_expression: String?, name: String?, tag: String?, merged_paths: Array[Array[Integer]]) -> instance
+
+          def self.members: () -> [ :index, :type, :node_path, :expression, :attribute, :key_source, :key_expression, :name, :tag, :merged_paths ]
+
+          def members: () -> [ :index, :type, :node_path, :expression, :attribute, :key_source, :key_expression, :name, :tag, :merged_paths ]
+        end
+
+        class Slot
+          # : () -> bool
+          def structural?: () -> bool
+
+          # : () -> bool
+          def attribute?: () -> bool
+
+          # : () -> bool
+          def anchored?: () -> bool
+
+          # : () -> bool
+          def nameable?: () -> bool
+
+          # : () -> bool
+          def valued?: () -> bool
+
+          # : () -> bool
+          def presence?: () -> bool
+
+          # : () -> bool
+          def interpolated?: () -> bool
+        end
+
+        # : (String) -> bool
+        def self.directive?: (String) -> bool
+
+        # : (String) -> Symbol?
+        def self.directive_mode: (String) -> Symbol?
+
+        # : () -> bool
+        def self.reads_erb_source?: () -> bool
+
+        # : (?markers: Markers, ?mode: Symbol, ?identifier: (Symbol | ^(String) -> String), ?mark: bool, ?deliver: Symbol, ?fatal: bool, ?static_markup: bool) -> void
+        def initialize: (?markers: Markers, ?mode: Symbol, ?identifier: Symbol | ^(String) -> String, ?mark: bool, ?deliver: Symbol, ?fatal: bool, ?static_markup: bool) -> void
+
+        # : () -> bool
+        def degraded?: () -> bool
+
+        # : () -> bool
+        def client?: () -> bool
+
+        # : () -> void
+        def state_overrides!: () -> void
+
+        # : () -> bool
+        def state_overrides?: () -> bool
+
+        # : (Integer, Array[String]) -> bool
+        def listener_writes?: (Integer, Array[String]) -> bool
+
+        # : (Integer) -> Array[Integer]
+        def slots_inside: (Integer) -> Array[Integer]
+
+        # : (untyped) -> bool
+        def fragment?: (untyped) -> bool
+
+        # : () -> Array[Integer]
+        def fragment_indexes: () -> Array[Integer]
+
+        # : (Integer) -> Hash[String, untyped]
+        def fragment_timing_for: (Integer) -> Hash[String, untyped]
+
+        # : (Array[untyped]) -> Array[untyped]
+        def transform_component_children: (Array[untyped]) -> Array[untyped]
+
+        # : (untyped, Array[untyped], Hash[String, untyped]) -> void
+        def record_fragment: (untyped, Array[untyped], Hash[String, untyped]) -> void
+
+        # : (Array[untyped]) -> void
+        def register_fallback_reads: (Array[untyped]) -> void
+
+        # : (untyped) -> bool
+        def fallback_state_read?: (untyped) -> bool
+
+        # : (untyped, mode: String, state: String, timing: Hash[String, Integer]) -> void
+        def record_deferred: (untyped, mode: String, state: String, timing: Hash[String, Integer]) -> void
+
+        # : (untyped) -> untyped
+        def record_assignment: (untyped) -> untyped
+
+        # : (untyped) -> bool
+        def assignment_node?: (untyped) -> bool
+
+        # : () -> Hash[Integer, Hash[Symbol, untyped]]
+        def deferred_entries: () -> Hash[Integer, Hash[Symbol, untyped]]
+
+        # : (Integer) -> Array[Array[Integer]]
+        def slots_by_branch: (Integer) -> Array[Array[Integer]]
+
+        # : (String, Herb::Location?, Symbol, ?suggestion: String?) -> nil
+        def slot_error: (String, Herb::Location?, Symbol, ?suggestion: String?) -> nil
+
+        # : (String, untyped, Symbol, ?suggestion: String?) -> void
+        def slot_warning: (String, untyped, Symbol, ?suggestion: String?) -> void
+
+        # : (Symbol) -> String
+        def diagnostic_code_for: (Symbol) -> String
+
+        # : () -> String
+        def version: () -> String
+
+        # : () -> Hash[Symbol, untyped]
+        def state_declarations: () -> Hash[Symbol, untyped]
+
+        # : () -> Array[Hash[Symbol, untyped]]
+        def state_entries: () -> Array[Hash[Symbol, untyped]]
+
+        # : () -> Hash[Integer, Hash[Symbol, untyped]]
+        def state_conditional_entries: () -> Hash[Integer, Hash[Symbol, untyped]]
+
+        # : () -> Hash[Integer, String]
+        def state_conditional_signatures: () -> Hash[Integer, String]
+
+        # : () -> Array[Hash[Symbol, untyped]]
+        def state_count_entries: () -> Array[Hash[Symbol, untyped]]
+
+        # : () -> Hash[Integer, untyped]
+        def state_presence: () -> Hash[Integer, untyped]
+
+        # : () -> Hash[Integer, untyped]
+        def state_values: () -> Hash[Integer, untyped]
+
+        # : () -> Array[String]
+        def seeded_region_states: () -> Array[String]
+
+        # : () -> Hash[Integer, Array[String]]
+        def seeded_item_states: () -> Hash[Integer, Array[String]]
+
+        # : () -> untyped
+        def current_collection: () -> untyped
+
+        # : (untyped) -> Array[String]
+        def block_locals: (untyped) -> Array[String]
+
+        # : (untyped) -> Array[String]
+        def parameter_names: (untyped) -> Array[String]
+
+        # : () -> bool
+        def in_item_body?: () -> bool
+
+        # : () -> bool
+        def inline?: () -> bool
+
+        # : (untyped) -> untyped
+        def open_tag_for: (untyped) -> untyped
+
+        # : (untyped) -> untyped
+        def scope_of: (untyped) -> untyped
+
+        # : (Integer, Slot) -> void
+        def replace_slot: (Integer, Slot) -> void
+
+        # : (untyped, Integer) -> void
+        def assign_index: (untyped, Integer) -> void
+
+        # : () -> bool
+        def marking?: () -> bool
+
+        # : () -> Array[String]
+        def version_projection: () -> Array[String]
+
+        # : () -> String
+        def inspect: () -> String
+
+        # : () -> String
+        def identifier: () -> String
+
+        # : () -> Hash[String, untyped]
+        def manifest: () -> Hash[String, untyped]
+
+        # : () -> Hash[String, Hash[String, untyped]]
+        def manifest_bindings: () -> Hash[String, Hash[String, untyped]]
+
+        # : (String) -> bool
+        def counted_state?: (String) -> bool
+
+        # : () -> Hash[String, Integer]
+        def manifest_names: () -> Hash[String, Integer]
+
+        # : () -> Hash[String, Array[String]]
+        def manifest_parts: () -> Hash[String, Array[String]]
+
+        # : () -> Hash[Symbol, untyped]
+        def schema: () -> Hash[Symbol, untyped]
+
+        # : () -> Array[Hash[Symbol, untyped]]
+        def slot_entries: () -> Array[Hash[Symbol, untyped]]
+
+        # : () -> Array[String]
+        def recorded_expressions: () -> Array[String]
+
+        # : (untyped) -> Integer?
+        def index_for: (untyped) -> Integer?
+
+        # : () -> String
+        def occurrence_expression: () -> String
+
+        # : (Herb::Location?) -> Herb::RubyProgram::Resolved?
+        def ruby_at: (Herb::Location?) -> Herb::RubyProgram::Resolved?
+
+        def visit_document_node: (untyped node) -> untyped
+
+        # : () -> Hash[String, String]?
+        def statics: () -> Hash[String, String]?
+
+        # : (untyped) -> void
+        def finish: (untyped) -> void
+
+        # : () -> void
+        def follow_replacements: () -> void
+
+        # : (untyped) -> void
+        def deliver_manifest: (untyped) -> void
+
+        def visit_html_element_node: (untyped node) -> untyped
+
+        def visit_erb_strict_locals_node: (untyped node) -> untyped
+
+        def visit_html_open_tag_node: (untyped node) -> untyped
+
+        def visit_erb_open_tag_node: (untyped node) -> untyped
+
+        def visit_html_attribute_node: (untyped node) -> untyped
+
+        def visit_html_comment_node: (untyped node) -> untyped
+
+        def visit_html_doctype_node: (untyped node) -> untyped
+
+        def visit_erb_content_node: (untyped node) -> untyped
+
+        def visit_erb_render_node: (untyped node) -> untyped
+
+        # : (untyped) -> void
+        def bind_render_states: (untyped) -> void
+
+        # : (RenderBindings::Entry, String, Callee?, Hash[String, String], Hash[String, String], Herb::Location?) -> void
+        def classify_binding: (RenderBindings::Entry, String, Callee?, Hash[String, String], Hash[String, String], Herb::Location?) -> void
+
+        # : (Symbol, Symbol) -> bool
+        def compatible_kinds?: (Symbol, Symbol) -> bool
+
+        # : (Symbol) -> String
+        def with_article: (Symbol) -> String
+
+        # : (String, Herb::Location?) -> void
+        def warn_binding_near_miss: (String, Herb::Location?) -> void
+
+        # : (untyped) -> [String?, Pathname?]
+        def child_template_for: (untyped) -> [ String?, Pathname? ]
+
+        # : (untyped) -> Array[String]
+        def similar_partials_for: (untyped) -> Array[String]
+
+        # : () -> void
+        def wrap_bound_renders: () -> void
+
+        def visit_erb_yield_node: (untyped node) -> untyped
+
+        def visit_erb_if_node: (untyped node) -> untyped
+
+        def visit_erb_unless_node: (untyped node) -> untyped
+
+        def visit_erb_else_node: (untyped node) -> untyped
+
+        def visit_erb_when_node: (untyped node) -> untyped
+
+        # : (untyped) -> void
+        def register_branch_directives: (untyped) -> void
+
+        def visit_erb_case_node: (untyped node) -> untyped
+
+        def visit_erb_block_node: (untyped node) -> untyped
+
+        def visit_erb_iteration_block_node: (untyped node) -> untyped
+
+        def visit_erb_while_node: (untyped node) -> untyped
+
+        def visit_erb_until_node: (untyped node) -> untyped
+
+        def visit_erb_for_node: (untyped node) -> untyped
+
+        def visit_collection_node: (untyped node) -> untyped
+
+        # : (untyped) -> bool
+        def continuation?: (untyped) -> bool
+
+        # : (untyped) -> bool
+        def exhaustive?: (untyped) -> bool
+
+        # : (untyped) -> Array[untyped]
+        def conditional_chain: (untyped) -> Array[untyped]
+
+        # : (untyped) -> bool
+        def blank_child?: (untyped) -> bool
+
+        # : (untyped) -> untyped
+        def continuation_of: (untyped) -> untyped
+
+        def text_node: (untyped content) -> untyped
+
+        def erb_code_node: (untyped code) -> untyped
+
+        def erb_output_node: (untyped code) -> untyped
+
+        private
+
+        def visit_children_with_paths: (untyped children) -> untyped
+
+        def visit_branching_node: (untyped node) -> untyped
+
+        # : (untyped) -> bool
+        def declares_slots?: (untyped) -> bool
+
+        # : (untyped) -> void
+        def transform_components: (untyped) -> void
+
+        # : (untyped) -> Array[untyped]
+        def transformed: (untyped) -> Array[untyped]
+
+        # : () -> void
+        def collapse_invariant_conditionals: () -> void
+
+        # : (untyped) -> Array[Integer]
+        def slot_indices_within: (untyped) -> Array[Integer]
+
+        # : (String) -> bool
+        def branching_shape?: (String) -> bool
+
+        # : () -> void
+        def number_slots: () -> void
+
+        # : (untyped, Symbol?) -> void
+        def record_slot: (untyped, Symbol?) -> void
+
+        # : (Symbol) -> Symbol?
+        def anchored_type_for: (Symbol) -> Symbol?
+
+        # : (Array[untyped]) -> Array[String]?
+        def rcdata_segments: (Array[untyped]) -> Array[String]?
+
+        # : (untyped) -> Array[String]
+        def listener_names_for: (untyped) -> Array[String]
+
+        # : (untyped) -> String?
+        def rcdata_expression_for: (untyped) -> String?
+
+        # : (Array[untyped]) -> bool
+        def mixed_rcdata_body?: (Array[untyped]) -> bool
+
+        # : (untyped) -> nil
+        def refuse_mixed_rcdata: (untyped) -> nil
+
+        # : (untyped) -> Symbol
+        def attribute_type_for: (untyped) -> Symbol
+
+        # : (untyped) -> untyped
+        def convert_helper_boolean_attribute: (untyped) -> untyped
+
+        # : (untyped, untyped, Integer, untyped, Integer) -> void
+        def record_named_element: (untyped, untyped, Integer, untyped, Integer) -> void
+
+        # : (untyped) -> String?
+        def static_attribute_value: (untyped) -> String?
+
+        # : () -> void
+        def apply_names: () -> void
+
+        # : (Hash[Symbol, untyped], Hash[String, Annotation]) -> void
+        def bind_name: (Hash[Symbol, untyped], Hash[String, Annotation]) -> void
+
+        # : (Hash[Symbol, untyped]) -> Annotation?
+        def resolve_named_slot: (Hash[Symbol, untyped]) -> Annotation?
+
+        # : (Hash[Symbol, untyped]) -> Herb::Location?
+        def name_location: (Hash[Symbol, untyped]) -> Herb::Location?
+
+        # : (String, Annotation, untyped) -> bool
+        def attribute_conflict?: (String, Annotation, untyped) -> bool
+
+        # : (untyped) -> void
+        def detect_keyed_elements: (untyped) -> void
+
+        # : (untyped) -> String?
+        def keyed_element_expression: (untyped) -> String?
+
+        # : (untyped) -> void
+        def remove_herb_key_attribute: (untyped) -> void
+
+        # : (untyped, Symbol) -> [Symbol?, String?]
+        def keys_for: (untyped, Symbol) -> [ Symbol?, String? ]
+
+        # : (untyped) -> [Symbol, String?]
+        def key_for: (untyped) -> [ Symbol, String? ]
+
+        # : (untyped) -> String?
+        def keyable_tag_name_for: (untyped) -> String?
+
+        # : (Array[untyped]) -> String?
+        def key_directive_in: (Array[untyped]) -> String?
+
+        # : (untyped) -> String?
+        def key_expression_for: (untyped) -> String?
+
+        # : (untyped) -> Array[[Symbol, String]]?
+        def key_parts_for: (untyped) -> Array[[ Symbol, String ]]?
+
+        # : (String) -> String
+        def escape_key_literal: (String) -> String
+
+        # : (untyped) -> Array[untyped]
+        def collection_body: (untyped) -> Array[untyped]
+
+        # : (untyped) -> Array[Herb::AST::HTMLAttributeNode]
+        def attributes_for: (untyped) -> Array[Herb::AST::HTMLAttributeNode]
+
+        # : (untyped) -> String?
+        def attribute_name_for: (untyped) -> String?
+
+        # : (untyped) -> bool
+        def dynamic?: (untyped) -> bool
+
+        def expression_for: (untyped node) -> untyped
+
+        # : (untyped) -> String?
+        def attribute_expression_for: (untyped) -> String?
+
+        def insert_markers: (untyped node) -> untyped
+
+        # : (untyped) -> Integer?
+        def content_anchor_index: (untyped) -> Integer?
+
+        # : (untyped, Integer?) -> void
+        def mark_branches: (untyped, Integer?) -> void
+
+        # : (String, Array[untyped]) -> void
+        def park_branch: (String, Array[untyped]) -> void
+
+        # : (Herb::AST::DocumentNode) -> void
+        def append_statics: (Herb::AST::DocumentNode) -> void
+
+        # : (Herb::AST::DocumentNode) -> void
+        def expose_fallbacks: (Herb::AST::DocumentNode) -> void
+
+        # : (Herb::AST::DocumentNode) -> void
+        def withdraw_fallbacks: (Herb::AST::DocumentNode) -> void
+
+        # : () -> Array[[String, Array[untyped]]]
+        def fallback_statics_entries: () -> Array[[ String, Array[untyped] ]]
+
+        # : (Array[untyped]) -> Array[untyped]
+        def marked_fallback: (Array[untyped]) -> Array[untyped]
+
+        # : (String) -> String
+        def covered_key: (String) -> String
+
+        # : (untyped) -> Array[Array[Herb::AST::Node]]
+        def branch_bodies: (untyped) -> Array[Array[Herb::AST::Node]]
+
+        # : (Herb::AST::Node, Integer?) -> void
+        def wrap_items: (Herb::AST::Node, Integer?) -> void
+
+        # : (untyped) -> Array[String]?
+        def attribute_segments: (untyped) -> Array[String]?
+
+        # : (Integer, untyped) -> void
+        def park_keyed: (Integer, untyped) -> void
+
+        # : (untyped, untyped) -> Array[untyped]?
+        def park_item: (untyped, untyped) -> Array[untyped]?
+
+        def anchor_attributes: (untyped node, ?untyped content_index) -> untyped
+
+        # : (Slot) -> String?
+        def anchor_name_for: (Slot) -> String?
+
+        # : (Herb::AST::Node) { (Array[untyped]) -> void } -> void
+        def each_child_array: (Herb::AST::Node) { (Array[untyped]) -> void } -> void
+
+        # : (Herb::AST::DocumentNode) -> void
+        def wrap_region: (Herb::AST::DocumentNode) -> void
+
+        # : () -> void
+        def wrap_displaced: () -> void
+
+        def region_open: () -> untyped
+
+        def comment_node: (untyped text) -> untyped
+
+        def attribute_node: (untyped name, untyped value) -> untyped
+
+        def literal: (untyped content) -> untyped
+
+        def token: (untyped type, untyped value) -> untyped
+      end
+    end
+  end
+end

data/sig/herb/engine/validators/accessibility_validator.rbs

@@ -3,7 +3,7 @@
 module Herb
   class Engine
     module Validators
-      class AccessibilityValidator < Validator
+      class AccessibilityValidator < Base
         def visit_html_attribute_node: (untyped node) -> untyped
 
         private

data/sig/herb/engine/validators/base.rbs

@@ -0,0 +1,28 @@
+# Generated from lib/herb/engine/validators/base.rb with RBS::Inline
+
+module Herb
+  class Engine
+    module Validators
+      # A visitor that reads the tree and reports what it finds without rewriting anything.
+      #
+      # There is nothing here a visitor cannot do on its own. Reporting comes from
+      # `Herb::Visitor::Diagnostics` and is open to any visitor, so a validator from somewhere else
+      # can include the mixins rather than subclass this. What this adds is the default a validator
+      # is expected to carry, which is that a finding refuses to compile unless a caller says
+      # otherwise:
+      #
+      #     Herb::Engine::Validators::SecurityValidator.new(fatal: false)
+      class Base < Herb::Visitor
+        include Herb::Visitor::ContextAware
+
+        include Herb::Visitor::Diagnostics
+
+        # : (?fatal: bool) -> void
+        def initialize: (?fatal: bool) -> void
+
+        # : () -> String
+        def inspect: () -> String
+      end
+    end
+  end
+end

data/sig/herb/engine/validators/generator_template_validator.rbs

@@ -0,0 +1,19 @@
+# Generated from lib/herb/engine/validators/generator_template_validator.rb with RBS::Inline
+
+module Herb
+  class Engine
+    module Validators
+      # Reports a template that writes literal ERB, which is a generator template and not a page.
+      #
+      # The engine itself compiles `<%%` to literal text the way Erubi does, so a sweep over a
+      # project's templates gets one of these instead of a file it cannot make sense of.
+      class GeneratorTemplateValidator < Base
+        def visit_erb_node: (untyped node) -> untyped
+
+        private
+
+        def validate_not_escaped: (untyped node) -> untyped
+      end
+    end
+  end
+end

data/sig/herb/engine/validators/nesting_validator.rbs

@@ -3,7 +3,7 @@
 module Herb
   class Engine
     module Validators
-      class NestingValidator < Validator
+      class NestingValidator < Base
         def visit_html_element_node: (untyped node) -> untyped
 
         private

data/sig/herb/engine/validators/render_validator.rbs

@@ -3,18 +3,14 @@
 module Herb
   class Engine
     module Validators
-      class RenderValidator < Validator
-        def initialize: (?enabled: untyped, ?filename: untyped, ?project_path: untyped) -> untyped
-
+      class RenderValidator < Base
         def visit_erb_render_node: (untyped node) -> untyped
 
         private
 
         def validate_partial_exists: (untyped node) -> untyped
 
-        def find_view_root: () -> untyped
-
-        def relative_to_project: (untyped path) -> untyped
+        def filename: () -> untyped
       end
     end
   end

data/sig/herb/engine/validators/security_validator.rbs

@@ -3,7 +3,7 @@
 module Herb
   class Engine
     module Validators
-      class SecurityValidator < Validator
+      class SecurityValidator < Base
         def visit_html_open_tag_node: (untyped node) -> untyped
 
         def visit_html_attribute_name_node: (untyped node) -> untyped
@@ -19,8 +19,6 @@ module Herb
         def conditional_tag_attributes_prism_node?: (untyped prism_node) -> untyped
 
         def add_security_error: (untyped location, untyped message, untyped suggestion) -> untyped
-
-        def add_diagnostic: (untyped message, untyped location, untyped severity, ?code: untyped, ?source: untyped, ?suggestion: untyped) -> untyped
       end
     end
   end