herb 0.10.4 → 0.11.0

data/sig/herb/analysis/render_graph/partial_call_site.rbs

@@ -0,0 +1,36 @@
+# Generated from lib/herb/analysis/render_graph/partial_call_site.rb with RBS::Inline
+
+module Herb
+  module Analysis
+    class RenderGraph
+      class PartialCallSite < Data
+        attr_reader caller(): untyped
+
+        attr_reader locals(): untyped
+
+        attr_reader ancestors(): untyped
+
+        attr_reader ancestor_attributes(): untyped
+
+        attr_reader via(): untyped
+
+        attr_reader location(): untyped
+
+        def self.new: (untyped caller, untyped locals, untyped ancestors, untyped ancestor_attributes, untyped via, untyped location) -> instance
+                    | (caller: untyped, locals: untyped, ancestors: untyped, ancestor_attributes: untyped, via: untyped, location: untyped) -> instance
+
+        def self.members: () -> [ :caller, :locals, :ancestors, :ancestor_attributes, :via, :location ]
+
+        def members: () -> [ :caller, :locals, :ancestors, :ancestor_attributes, :via, :location ]
+      end
+
+      class PartialCallSite
+        # : (Hash[String, untyped]) -> PartialCallSite
+        def self.from: (Hash[String, untyped]) -> PartialCallSite
+
+        # : () -> Hash[String, untyped]
+        def to_h: () -> Hash[String, untyped]
+      end
+    end
+  end
+end

data/sig/herb/analysis/render_graph/partial_context.rbs

@@ -0,0 +1,31 @@
+# Generated from lib/herb/analysis/render_graph/partial_context.rb with RBS::Inline
+
+module Herb
+  module Analysis
+    class RenderGraph
+      class PartialContext < Data
+        attr_reader chains(): untyped
+
+        attr_reader resolved(): untyped
+
+        def self.new: (untyped chains, untyped resolved) -> instance
+                    | (chains: untyped, resolved: untyped) -> instance
+
+        def self.members: () -> [ :chains, :resolved ]
+
+        def members: () -> [ :chains, :resolved ]
+      end
+
+      class PartialContext
+        # : (Array[String], *String) -> Symbol
+        def ancestor_verdict: (Array[String], *String) -> Symbol
+
+        # : (Array[String], *String) -> String?
+        def closest_ancestor: (Array[String], *String) -> String?
+
+        # : (Array[String], Array[String]) -> String?
+        def innermost: (Array[String], Array[String]) -> String?
+      end
+    end
+  end
+end

data/sig/herb/analysis/render_graph/template_roots.rbs

@@ -0,0 +1,32 @@
+# Generated from lib/herb/analysis/render_graph/template_roots.rb with RBS::Inline
+
+module Herb
+  module Analysis
+    class RenderGraph
+      class TemplateRoots < Data
+        attr_reader tags(): untyped
+
+        attr_reader conditional_tags(): untyped
+
+        attr_reader renders(): untyped
+
+        attr_reader resolved(): untyped
+
+        def self.new: (untyped tags, untyped conditional_tags, untyped renders, untyped resolved) -> instance
+                    | (tags: untyped, conditional_tags: untyped, renders: untyped, resolved: untyped) -> instance
+
+        def self.members: () -> [ :tags, :conditional_tags, :renders, :resolved ]
+
+        def members: () -> [ :tags, :conditional_tags, :renders, :resolved ]
+      end
+
+      class TemplateRoots
+        # : (Hash[String, untyped]) -> TemplateRoots
+        def self.from: (Hash[String, untyped]) -> TemplateRoots
+
+        # : () -> Hash[String, untyped]
+        def to_h: () -> Hash[String, untyped]
+      end
+    end
+  end
+end

data/sig/herb/analysis/render_graph.rbs

@@ -0,0 +1,83 @@
+# Generated from lib/herb/analysis/render_graph.rb with RBS::Inline
+
+module Herb
+  module Analysis
+    class RenderGraph
+      MAX_ANCESTOR_CHAINS: Integer
+
+      NO_ROOTS: TemplateRoots
+
+      UNRESOLVED: PartialContext
+
+      DOCUMENT_ROOT: PartialContext
+
+      # : (Hash[String, untyped]) -> RenderGraph
+      def self.from: (Hash[String, untyped]) -> RenderGraph
+
+      # : (?Hash[String, Array[PartialCallSite]], ?Hash[String, TemplateRoots], ?Set[String], ?Hash[String, Integer], ?Set[String]) -> void
+      def initialize: (?Hash[String, Array[PartialCallSite]], ?Hash[String, TemplateRoots], ?Set[String], ?Hash[String, Integer], ?Set[String]) -> void
+
+      # : () -> Integer
+      def unresolved_render_count: () -> Integer
+
+      # : () -> Integer
+      def skipped_file_count: () -> Integer
+
+      # : () -> bool
+      def complete?: () -> bool
+
+      # : (String) -> TemplateRoots
+      def roots_of: (String) -> TemplateRoots
+
+      # : (String, TemplateRoots) -> void
+      def set_roots: (String, TemplateRoots) -> void
+
+      # : (String) -> Array[PartialCallSite]
+      def callers_of: (String) -> Array[PartialCallSite]
+
+      # : (String) -> void
+      def add_document_root: (String) -> void
+
+      # : (String) -> bool
+      def document_root?: (String) -> bool
+
+      # : (String) -> void
+      def skip: (String) -> void
+
+      # : (String, Hash[String, Array[PartialCallSite]], ?Integer) -> bool
+      def replace_calls_from: (String, Hash[String, Array[PartialCallSite]], ?Integer) -> bool
+
+      # : (String) -> bool
+      def remove_calls_to: (String) -> bool
+
+      # : (String) -> InferredSignature
+      def infer_signature: (String) -> InferredSignature
+
+      # : (String) -> PartialContext
+      def context_of: (String) -> PartialContext
+
+      # : (Array[String], *String) -> Symbol
+      def descendant_verdict: (Array[String], *String) -> Symbol
+
+      # : () -> Integer
+      def size: () -> Integer
+
+      # : () -> Hash[String, untyped]
+      def to_h: () -> Hash[String, untyped]
+
+      private
+
+      # : (String, Integer) -> bool
+      def replace_unresolved_from: (String, Integer) -> bool
+
+      # : (String, Array[String], Set[String]) -> Symbol
+      def root_verdict: (String, Array[String], Set[String]) -> Symbol
+
+      # : (String, Set[String]) -> PartialContext
+      def resolve_context: (String, Set[String]) -> PartialContext
+
+      # : (PartialCallSite) -> CallFrame
+      def frame_for: (PartialCallSite) -> CallFrame
+    end
+  end
+end

data/sig/herb/analysis/ruby_locals_index/local.rbs

@@ -0,0 +1,21 @@
+# Generated from lib/herb/analysis/ruby_locals_index/local.rb with RBS::Inline
+
+module Herb
+  module Analysis
+    class RubyLocalsIndex
+      class Local
+        attr_reader name: String
+
+        attr_reader declaration: Herb::Location
+
+        attr_reader usages: Array[Herb::Location]
+
+        # : (String, Herb::Location, Array[Herb::Location]) -> void
+        def initialize: (String, Herb::Location, Array[Herb::Location]) -> void
+
+        # : () -> Array[Herb::Location]
+        def locations: () -> Array[Herb::Location]
+      end
+    end
+  end
+end

data/sig/herb/analysis/ruby_locals_index/named_reference.rbs

@@ -0,0 +1,20 @@
+# Generated from lib/herb/analysis/ruby_locals_index/named_reference.rb with RBS::Inline
+
+module Herb
+  module Analysis
+    class RubyLocalsIndex
+      # A name, with where it appears in the source as a byte offset and length,
+      # which is how Prism reports it.
+      class NamedReference
+        attr_reader name: String
+
+        attr_reader start_offset: Integer
+
+        attr_reader length: Integer
+
+        # : (String, Integer, Integer) -> void
+        def initialize: (String, Integer, Integer) -> void
+      end
+    end
+  end
+end

data/sig/herb/analysis/ruby_locals_index/offset_table.rbs

@@ -0,0 +1,26 @@
+# Generated from lib/herb/analysis/ruby_locals_index/offset_table.rb with RBS::Inline
+
+module Herb
+  module Analysis
+    class RubyLocalsIndex
+      # Prism reports byte offsets into the whole template while the Herb AST
+      # reports lines and 0-based character columns, so one of them has to be
+      # translated. The line table stays in bytes to index into the source, and
+      # only the column is counted in characters.
+      class OffsetTable
+        attr_reader source: String
+
+        attr_reader line_starts: Array[Integer]
+
+        # : (String) -> void
+        def initialize: (String) -> void
+
+        # : (NamedReference) -> Herb::Location
+        def location_for: (NamedReference) -> Herb::Location
+
+        # : (Integer) -> [Integer, Integer]
+        def position_at: (Integer) -> [ Integer, Integer ]
+      end
+    end
+  end
+end

data/sig/herb/analysis/ruby_locals_index/reference_collector.rbs

@@ -0,0 +1,40 @@
+# Generated from lib/herb/analysis/ruby_locals_index/reference_collector.rb with RBS::Inline
+
+module Herb
+  module Analysis
+    class RubyLocalsIndex
+      class ReferenceCollector
+        attr_reader local_reads: Array[NamedReference]
+
+        attr_reader bare_calls: Array[NamedReference]
+
+        attr_reader parameters: Array[NamedReference]
+
+        attr_reader assignments: Array[NamedReference]
+
+        # : (Prism::Node) -> void
+        def initialize: (Prism::Node) -> void
+
+        private
+
+        # : (Prism::Node) -> void
+        def walk: (Prism::Node) -> void
+
+        # : (Prism::Node) -> void
+        def record: (Prism::Node) -> void
+
+        # : (Prism::Node) -> void
+        def record_read: (Prism::Node) -> void
+
+        # : (Prism::Node) -> void
+        def record_binding: (Prism::Node) -> void
+
+        # : (Prism::CallNode) -> bool
+        def bare_call?: (Prism::CallNode) -> bool
+
+        # : (Array[NamedReference], Symbol?, Prism::Location?) -> void
+        def add: (Array[NamedReference], Symbol?, Prism::Location?) -> void
+      end
+    end
+  end
+end

data/sig/herb/analysis/ruby_locals_index/state_locals.rbs

@@ -0,0 +1,19 @@
+# Generated from lib/herb/analysis/ruby_locals_index/state_locals.rb with RBS::Inline
+
+module Herb
+  module Analysis
+    class RubyLocalsIndex
+      # Finds `herb:state` declarations so a state read indexes like a local instead of an
+      # unknown name.
+      module StateLocals
+        def self?.locals: (untyped document, untyped references, untyped offsets, untyped declared) -> untyped
+
+        def self?.directives: (untyped document) -> untyped
+
+        def self?.declarations_in: (untyped node, untyped known) -> untyped
+
+        def self?.usages: (untyped name, untyped references, untyped offsets) -> untyped
+      end
+    end
+  end
+end

data/sig/herb/analysis/ruby_locals_index.rbs

@@ -0,0 +1,62 @@
+# Generated from lib/herb/analysis/ruby_locals_index.rb with RBS::Inline
+
+module Herb
+  module Analysis
+    class RubyLocalsIndex
+      KEYWORD_KIND: String
+
+      attr_reader locals: Array[Local]
+
+      attr_reader assignment_names: Set[String]
+
+      # : (String) -> RubyLocalsIndex
+      def self.from_source: (String) -> RubyLocalsIndex
+
+      # : (Herb::AST::DocumentNode, String) -> RubyLocalsIndex
+      def self.from_document: (Herb::AST::DocumentNode, String) -> RubyLocalsIndex
+
+      # : (Array[Local], ?Set[String]) -> void
+      def initialize: (Array[Local], ?Set[String]) -> void
+
+      # : (Integer, Integer) -> Local?
+      def at: (Integer, Integer) -> Local?
+
+      # : (String) -> Local?
+      def find: (String) -> Local?
+
+      # Every name the template binds, regardless of where.
+      # : () -> Set[String]
+      def names: () -> Set[String]
+
+      # : (Herb::Location, Integer, Integer) -> bool
+      def self.covers?: (Herb::Location, Integer, Integer) -> bool
+
+      # : (Herb::Location, Herb::Location) -> bool
+      def self.encloses?: (Herb::Location, Herb::Location) -> bool
+
+      # : (Herb::AST::DocumentNode, ReferenceCollector, OffsetTable) -> Array[Local]
+      def self.strict_locals: (Herb::AST::DocumentNode, ReferenceCollector, OffsetTable) -> Array[Local]
+
+      # : (Herb::AST::DocumentNode) -> Array[[String, Herb::Location]]
+      def self.declarations: (Herb::AST::DocumentNode) -> Array[[ String, Herb::Location ]]
+
+      # : (Herb::AST::Node) -> [String, Herb::Location]?
+      def self.declaration_for: (Herb::AST::Node) -> [ String, Herb::Location ]?
+
+      # : (Herb::AST::DocumentNode, ReferenceCollector, OffsetTable) -> Array[Local]
+      def self.block_locals: (Herb::AST::DocumentNode, ReferenceCollector, OffsetTable) -> Array[Local]
+
+      # : (NamedReference, ReferenceCollector, OffsetTable, Herb::Location?) -> Array[Herb::Location]
+      def self.reads_in_scope: (NamedReference, ReferenceCollector, OffsetTable, Herb::Location?) -> Array[Herb::Location]
+
+      # : (Herb::AST::DocumentNode) -> Array[Herb::Location]
+      def self.block_locations: (Herb::AST::DocumentNode) -> Array[Herb::Location]
+
+      # : (Herb::AST::Node) -> bool
+      def self.block_node?: (Herb::AST::Node) -> bool
+
+      # : (Array[Herb::Location], Herb::Location) -> Herb::Location?
+      def self.innermost_enclosing: (Array[Herb::Location], Herb::Location) -> Herb::Location?
+    end
+  end
+end

data/sig/herb/analysis/ruby_reference.rbs

@@ -0,0 +1,28 @@
+# Generated from lib/herb/analysis/ruby_reference.rb with RBS::Inline
+
+module Herb
+  module Analysis
+    # Answers whether a snippet of Ruby references a name, instead of merely containing its
+    # characters. `render "form"` does not reference a local named `form`, and `item.title` does
+    # not reference a local named `title`.
+    #
+    #     Herb::Analysis::RubyReference.references?("render 'form'", "form") #=> false
+    #     Herb::Analysis::RubyReference.references?("render form", "form")   #=> true
+    #
+    # A name that cannot be parsed falls back to matching the source, since a dependency that is
+    # missed goes stale while one that is imagined only costs a rebuild.
+    class RubyReference
+      # : (String?, String?) -> bool
+      def self.references?: (String?, String?) -> bool
+
+      # : (String) -> Regexp
+      def self.boundary: (String) -> Regexp
+
+      # : (String) -> Array[untyped]?
+      def self.nodes_in: (String) -> Array[untyped]?
+
+      # : (untyped, String) -> bool
+      def self.names?: (untyped, String) -> bool
+    end
+  end
+end

data/sig/herb/analysis/template_dependencies/dependency_collector.rbs

@@ -0,0 +1,52 @@
+# Generated from lib/herb/analysis/template_dependencies/dependency_collector.rb with RBS::Inline
+
+module Herb
+  module Analysis
+    class TemplateDependencies
+      class DependencyCollector < ::Herb::Visitor
+        attr_reader instance_variables: untyped
+
+        attr_reader constants: untyped
+
+        attr_reader locals_declared: untyped
+
+        attr_reader locals_received: untyped
+
+        attr_reader helper_calls: untyped
+
+        attr_reader unknown_calls: untyped
+
+        attr_reader render_calls: untyped
+
+        def initialize: (untyped helper_registry, untyped custom_helpers, ?untyped prescanned_locals) -> untyped
+
+        def visit_erb_iteration_block_node: (untyped node) -> untyped
+
+        def visit_erb_block_node: (untyped node) -> untyped
+
+        def visit_erb_node: (untyped node) -> untyped
+
+        def visit_erb_render_node: (untyped node) -> untyped
+
+        def visit_erb_strict_locals_node: (untyped node) -> untyped
+
+        private
+
+        def analyze_erb_node: (untyped erb_node) -> untyped
+
+        # : (untyped, iterating: bool) { () -> void } -> void
+        def within_block: (untyped, iterating: bool) { () -> void } -> void
+
+        def block_parameters: (untyped code) -> untyped
+
+        def collect_parameters: (untyped node, untyped names) -> untyped
+
+        def analyze_ruby_expression: (untyped code) -> untyped
+
+        def walk_prism_node: (untyped node) -> untyped
+
+        def check_call_node: (untyped node) -> untyped
+      end
+    end
+  end
+end

data/sig/herb/analysis/template_dependencies/node_dependency_collector.rbs

@@ -0,0 +1,81 @@
+# Generated from lib/herb/analysis/template_dependencies/node_dependency_collector.rb with RBS::Inline
+
+module Herb
+  module Analysis
+    class TemplateDependencies
+      class NodeDependencyCollector < ::Herb::Visitor
+        BRANCH_BODY_PROPERTIES: Array[Symbol]
+
+        BRANCH_CONTINUATION_PROPERTIES: Array[Symbol]
+
+        ASSIGNMENT_NODES: Array[untyped]
+
+        attr_reader affected: untyped
+
+        def initialize: (untyped state, untyped helper_registry, untyped custom_helpers, ?conditions_only: untyped) -> untyped
+
+        def visit_document_node: (untyped node) -> untyped
+
+        def visit_html_element_node: (untyped node) -> untyped
+
+        def visit_html_open_tag_node: (untyped node) -> untyped
+
+        def visit_erb_content_node: (untyped node) -> untyped
+
+        def visit_erb_if_node: (untyped node) -> untyped
+
+        def visit_erb_unless_node: (untyped node) -> untyped
+
+        def visit_erb_case_node: (untyped node) -> untyped
+
+        def visit_erb_node: (untyped node) -> untyped
+
+        def visit_erb_render_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
+
+        private
+
+        def visit_children_with_paths: (untyped children) -> untyped
+
+        def check_block_for_state: (untyped node, untyped type) -> untyped
+
+        def visit_branching_node: (untyped node) -> untyped
+
+        def bind_assignments: (untyped node) -> untyped
+
+        def assigned_names: (untyped code) -> untyped
+
+        def collect_assignments: (untyped node, untyped names) -> untyped
+
+        def right_hand_side: (untyped node) -> untyped
+
+        def bindings_for: (untyped node) -> untyped
+
+        def block_parameters: (untyped code) -> untyped
+
+        def collect_parameters: (untyped node, untyped names) -> untyped
+
+        def own_expression: (untyped node) -> untyped
+
+        def collect_all_expressions: (untyped node) -> untyped
+
+        def check_erb_expression: (untyped node, untyped type) -> untyped
+
+        def check_attribute: (untyped attribute_node, untyped path) -> untyped
+
+        def references_state?: (untyped code) -> untyped
+
+        def references_name?: (untyped code, untyped name) -> untyped
+      end
+    end
+  end
+end

data/sig/herb/analysis/template_dependencies.rbs

@@ -0,0 +1,125 @@
+# Generated from lib/herb/analysis/template_dependencies.rb with RBS::Inline
+
+module Herb
+  module Analysis
+    class TemplateDependencies
+      class FlowNode < Data
+        attr_reader file(): untyped
+
+        attr_reader names(): untyped
+
+        attr_reader via(): untyped
+
+        attr_reader nodes(): untyped
+
+        attr_reader children(): untyped
+
+        def self.new: (untyped file, untyped names, untyped via, untyped nodes, untyped children) -> instance
+                    | (file: untyped, names: untyped, via: untyped, nodes: untyped, children: untyped) -> instance
+
+        def self.members: () -> [ :file, :names, :via, :nodes, :children ]
+
+        def members: () -> [ :file, :names, :via, :nodes, :children ]
+      end
+
+      class Result < Data
+        attr_reader file(): untyped
+
+        attr_reader instance_variables(): untyped
+
+        attr_reader constants(): untyped
+
+        attr_reader locals_declared(): untyped
+
+        attr_reader locals_received(): untyped
+
+        attr_reader render_calls(): untyped
+
+        attr_reader helper_calls(): untyped
+
+        attr_reader unknown_calls(): untyped
+
+        def self.new: (untyped file, untyped instance_variables, untyped constants, untyped locals_declared, untyped locals_received, untyped render_calls, untyped helper_calls, untyped unknown_calls) -> instance
+                    | (file: untyped, instance_variables: untyped, constants: untyped, locals_declared: untyped, locals_received: untyped, render_calls: untyped, helper_calls: untyped, unknown_calls: untyped) -> instance
+
+        def self.members: () -> [ :file, :instance_variables, :constants, :locals_declared, :locals_received, :render_calls, :helper_calls, :unknown_calls ]
+
+        def members: () -> [ :file, :instance_variables, :constants, :locals_declared, :locals_received, :render_calls, :helper_calls, :unknown_calls ]
+      end
+
+      def initialize: (untyped project_path) -> untyped
+
+      def analyze: (untyped file_path) -> untyped
+
+      def affected_templates: (untyped entry_point, untyped state) -> untyped
+
+      def state_flow: (untyped entry_point, untyped state) -> untyped
+
+      def affected_nodes: (untyped file_path, untyped state, ?conditions_only: untyped) -> untyped
+
+      def nodes_in: (untyped ast, untyped state, ?conditions_only: untyped) -> untyped
+
+      def dependency_index: (untyped file_path) -> untyped
+
+      # @rbs!
+      #   KERNEL_METHODS: Array[String]
+      KERNEL_METHODS: untyped
+
+      def scan_helpers!: () -> untyped
+
+      private
+
+      # : (String) -> Set[String]
+      def guarded_locals: (String) -> Set[String]
+
+      # : () -> Set[String]
+      def scan_helper_methods!: () -> Set[String]
+
+      # : () -> Set[String]
+      def scan_routes!: () -> Set[String]
+
+      # : (String) -> void
+      def add_route_pair: (String) -> void
+
+      # : (String, String) -> String?
+      def symbol_after: (String, String) -> String?
+
+      # @rbs!
+      #   UNCOUNTABLE: Array[String]
+      UNCOUNTABLE: untyped
+
+      # : (String, String) -> String?
+      def keyword_value: (String, String) -> String?
+
+      # : (String) -> String?
+      def route_alias: (String) -> String?
+
+      # : (String) -> String
+      def singularize: (String) -> String
+
+      def trace_state: (untyped entry_point, untyped state) -> untyped
+
+      def flow_node: (untyped trace, untyped file, untyped via, untyped path) -> untyped
+
+      def nodes_for: (untyped file, untyped names) -> untyped
+
+      def collect_reachable_files: (untyped entry_point) -> untyped
+
+      def component_methods_for: (untyped template_path) -> untyped
+
+      def partial_index: () -> untyped
+
+      def iterated_names: (untyped call, untyped carrying) -> untyped
+
+      def expression_references?: (untyped expression, untyped name) -> untyped
+
+      def extract_helper_methods: (untyped file) -> untyped
+
+      def walk_for_defs: (untyped node, untyped methods) -> untyped
+
+      def load_helper_registry: () -> untyped
+
+      def find_view_root: () -> untyped
+    end
+  end
+end