Overview

• module Decode
  • module Comment

    Represents comment parsing and processing functionality.

    • class Attribute

      Describes an attribute type.
    • class Node

      Represents a node in a comment tree structure.
    • class Option

      Describes a method option (keyword argument).
    • class Parameter

      Represents a named method parameter.
    • class Pragma

      Asserts a specific property about the method signature.
    • class Raises

      Identifies that a method might raise an exception.
    • class RBS

      Represents an RBS type annotation following rbs-inline syntax.
    • class Returns

      Represents a return value.
    • class Tag

      Represents a documentation tag parsed from a comment directive.
    • class Tags

      Represents a collection of documentation tags and their parsing logic.
    • class Text

      A structured comment.
    • class Throws

      Identifies that a method might throw a specific symbol.
    • class Yields

      Describes a block parameter.
  • class Definition

    A symbol with attached documentation.
  • class Documentation

    Structured access to a set of comment lines.
  • class Index

    Represents a list of definitions organised for quick lookup and lexical enumeration.
  • module Language

    Language specific parsers and definitions.

    • class Generic

      Represents a generic language implementation that can be extended for specific languages.
    • class Reference

      An reference which can be resolved to zero or more definitions.
    • module Ruby

      Represents an interface for extracting information from Ruby source code.

      • class Alias

        Represents an alias statement, e.g., alias new_name old_name or alias_method :new_name, :old_name
      • class Attribute

        A Ruby-specific attribute.
      • class Block

        A Ruby-specific block which might carry other definitions.
      • class Call

        A Ruby-specific block which might carry other definitions.
      • class Class

        A Ruby-specific class.
      • class Singleton

        A Ruby-specific singleton class.
      • class Code

        A Ruby-specific block of code.
      • class Constant

        A Ruby-specific constant.
      • class Definition

        Represents a Ruby-specific definition extracted from source code.
      • class Function

        A Ruby-specific function.
      • class Generic

        Represents the Ruby language implementation for parsing and analysis.
      • class Method

        A Ruby-specific method.
      • class Module

        A Ruby-specific module.
      • class Parser

        The Ruby source code parser.
      • class Reference

        An Ruby-specific reference which can be resolved to zero or more definitions.
      • class Segment

        A Ruby specific code segment.
  • class Languages

    Represents a context for looking up languages based on file extension or name.
  • class Location

    Represents a location in a source file.
  • module RBS

    RBS generation functionality for Ruby type signatures.

    • class Class

      Represents a Ruby class definition wrapper for RBS generation.
    • class Generator

      Represents a generator for RBS type declarations.
    • class Method

      Represents a Ruby method definition wrapper for RBS generation.
    • class Module

      Represents a Ruby module definition wrapper for RBS generation.
    • class Wrapper

      Base wrapper class for RBS generation from definitions.
  • class Scope

    An abstract namespace for nesting definitions.
  • class Segment

    A chunk of code with an optional preceeding comment block.
  • class Source

    Represents a source file in a specific language.
  • module Syntax

    Provides syntax rewriting and linking functionality.

    • class Link

      Represents a link to a definition in the documentation.
    • class Match

      Represents a match in the source text for syntax rewriting.
    • class Rewriter

      Provides text rewriting functionality with match-based substitutions.
  • class Trie

    Represents a prefix-trie data structure for fast lexical lookups.

    • class Node

      Represents a single node in the trie.