docrb-parser 0.1.0

data/lib/docrb/parser/virtual_method.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Docrb
+  class Parser
+    class VirtualMethod
+      VirtualReceiver = Data.define(:type)
+
+      attr_accessor :name, :parameters, :receiver
+
+      def type = :def_node
+
+      def initialize(name, receiver, parameters = nil)
+        @name = name
+        @receiver = VirtualReceiver.new(type: receiver)
+        @parameters = parameters
+      end
+    end
+  end
+end

data/lib/docrb/parser.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "parser/reloader"
+
+require_relative "parser/version"
+require_relative "core_extensions"
+require_relative "parser/node_array"
+
+require_relative "parser/method"
+require_relative "parser/location"
+require_relative "parser/method_parameters"
+require_relative "parser/container"
+require_relative "parser/class"
+require_relative "parser/deferred_singleton_class"
+require_relative "parser/module"
+require_relative "parser/reference"
+require_relative "parser/call"
+require_relative "parser/attribute"
+require_relative "parser/constant"
+require_relative "parser/comment"
+
+require_relative "parser/virtual_method"
+require_relative "parser/virtual_location"
+require_relative "parser/virtual_container"
+
+require_relative "parser/resolved_reference"
+require_relative "parser/computations"
+require_relative "parser/comment_parser"
+
+module Docrb
+  class Parser
+    attr_reader :current_file, :locations, :references, :nodes
+    attr_accessor :debug, :ast_lines
+
+    def initialize
+      @current_ast = nil
+      @current_file = nil
+      @locations = []
+      @references = []
+      @ast_lines = {}
+      @object_by_id = {}
+      @current_object_id = 1
+      @nodes = NodeArray.new
+    end
+
+    def lines_for(file, ast)
+      return ast_lines[file] if ast_lines.key? file
+
+      ast.source.source.split("\n").tap { ast_lines[file] = _1 }
+    end
+
+    def all_objects = @object_by_id.values
+    def all_classes = all_objects.filter { _1.is_a? Class }
+    def all_modules = all_objects.filter { _1.is_a? Module }
+    def all_methods = all_objects.filter { _1.is_a? Method }
+
+    def finalize = Computations.new(self).tap(&:run)
+
+    docrb_inspect_attrs(:current_file, :locations, :references, :nodes)
+
+    def parse(file)
+      tap do
+        @current_file = file
+        @current_ast = Prism.parse_file(file)
+        @nodes.append(*@current_ast.value.statements.body.map { handle_node(_1) }.reject { _1.is_a? Call })
+      end
+    end
+
+    def make_id(obj)
+      @current_object_id.tap do |id|
+        @object_by_id[id] = obj
+        @current_object_id += 1
+      end
+    end
+
+    def object_by_id(id) = @object_by_id[id]
+
+    def handle_node(node, parent = nil)
+      case node.type
+      when :def_node then Method.new(self, parent, node)
+      when :class_node then Class.new(self, parent, node)
+      when :module_node then Module.new(self, parent, node)
+      when :singleton_class_node then handle_singleton_class(parent, node)
+      when :call_node then Call.new(self, parent, node)
+      when :constant_write_node then Constant.new(self, parent, node)
+      else unhandled_node!(node)
+      end
+    end
+
+    def unhandled_node!(node)
+      return unless debug
+
+      bs = caller_locations[1...].join("\n")
+      type = node.try(:type) || node.class.name
+      warn "Warning: Unhandled node type #{type}\n#{bs}\n#{node}"
+    end
+
+    def location(loc)
+      return loc if loc.is_a? Location
+
+      Location.new(self, @current_ast, loc).tap { @locations << _1 }
+    end
+
+    def reference(parent, path)
+      raise ArgumentError, "Empty path" if path.nil? || path.empty?
+
+      Reference.new(self, parent, path).tap { @references << _1 }
+    end
+
+    def attach_sources!
+      @locations.each(&:load_source!)
+    end
+
+    def unfurl_constant_path(node)
+      return [] unless node
+      return [node.name] if node.type == :constant_read_node
+
+      [].tap do |segments|
+        while node&.type == :constant_path_node
+          segments << node.child.name
+          node = node.parent
+        end
+        segments << (node&.name || :root!)
+        segments.reverse!
+      end
+    end
+
+    def handle_singleton_class(parent, node)
+      case node.expression.type
+      when :self_node
+        Class.new(self, parent, node).tap(&:singleton!)
+      else
+        DeferredSingletonClass.new(self, parent, node)
+      end
+    end
+  end
+end

data/lib/docrb-parser.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "docrb/parser"

data/sig/docrb/core_extensions.rbs

@@ -0,0 +1,24 @@
+class Object
+  self.@__inspect_installed__: bool
+
+  def own_methods: -> Array[Symbol]
+  def object_id_hex: -> String
+
+  def self.docrb_inspect: { (void) -> String } -> String
+  def self.docrb_inspect_attrs: (*Symbol attrs) -> void
+  def self.visible_attr_reader: (*Symbol args) -> void
+  def self.visible_attr_Accessor: (*Symbol args) -> void
+
+  def try: (String | Symbol method, *untyped args,  **untyped kwargs) ?{ (untyped) -> untyped } -> untyped
+  def attr_list: (*String names) -> String
+end
+
+class Array[unchecked out Elem] < Object
+  def first!: () -> Elem
+
+  alias old_first first
+end
+
+module Kernel
+  def then!: () { (self) -> untyped } -> (nil | untyped)
+end

data/sig/docrb/parser/attribute.rbs

@@ -0,0 +1,18 @@
+module Docrb
+  class Parser
+    class Attribute
+      type kind = :writer | :reader | :accessor
+
+      attr_reader name: Symbol
+      attr_reader location: Location
+      attr_accessor writer_visibility: Container::visibility
+      attr_accessor reader_visibility: Container::visibility
+      attr_accessor type: kind
+      attr_accessor parent: Container
+
+      def initialize: (Parser parser, Container parent, untyped node, Symbol name, kind `type`) -> void
+
+      def id: () -> Integer
+    end
+  end
+end

data/sig/docrb/parser/call.rbs

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+module Docrb
+  class Parser
+    class Call
+      attr_reader name: String
+      attr_reader arguments: Array[untyped]
+      attr_reader parent: Container
+      attr_reader location: Location
+
+      @object_id: Integer
+
+      def initialize: (Parser parser, Container parent, untyped node) -> void
+
+      def id: () -> Integer
+    end
+  end
+end

data/sig/docrb/parser/class.rbs

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+module Docrb
+  class Parser
+    class Class < Container
+      attr_accessor node: untyped
+      attr_accessor inherits: Reference?
+      attr_accessor singleton: bool
+
+      def kind: () -> :class
+
+      def initialize: (Parser parser, Container? parent, untyped node) -> void
+
+      def unowned_classes: () -> NodeArray[Class]
+
+      def unowned_modules: () -> NodeArray[Module]
+
+      def unowned_instance_methods: () -> NodeArray[Method]
+
+      def unowned_class_methods: () -> NodeArray[Method]
+
+      def unowned_class_attributes: () -> NodeArray[Attribute]
+
+      def unowned_instance_attributes: () -> NodeArray[Attribute]
+
+      def singleton!: () -> self
+
+      def singleton?: () -> bool
+
+      def handle_parsed_node: (Parser parser, untyped node) ->  void
+
+      def merge_singleton_class: (Class other) -> void
+    end
+  end
+end

data/sig/docrb/parser/comment.rbs

@@ -0,0 +1,14 @@
+module Docrb
+  class Parser
+    class Comment
+      @location: Location
+      @file_path: String
+      @parser: Parser
+      @comments: Array[String]?
+
+      def initialize: (Parser parser, Location location, String file_path) -> void
+
+      def locate: () -> void
+    end
+  end
+end

data/sig/docrb/parser/comment_parser.rbs

@@ -0,0 +1,79 @@
+module Docrb
+  class Parser
+    class CommentParser
+      type untyped_hash = Hash[untyped, untyped]
+      type replacement_object = { start_idx: Integer, end_idx: Integer, object: untyped_hash }
+
+      NEWLINE: "\n"
+      POUND: "#"
+      SPACE: ""
+      DASH: "-"
+      COLON: ":"
+
+      @data: Array[String]
+
+      @data_len: Integer
+
+      attr_accessor objects: Array[untyped_hash] | Array[String]
+      attr_accessor current_object: Array[String]
+      attr_accessor cursor: Integer
+      attr_accessor visibility: String?
+
+      def self.parse: (String data) -> untyped_hash
+
+      def initialize: (String data) -> void
+
+      def at_end?: () -> bool
+      def will_end?: () -> bool
+      def at_start?: () -> bool
+      def peek: () -> String?
+      def peek_next: () -> String?
+      def peek_prev: () -> String?
+      def advance: () -> String?
+      def match?: (*String args) -> bool
+      def consume_spaces: () -> nil
+      def extract_while: () { () -> bool } -> void
+      def extract_until: () { () -> bool } -> void
+
+      def parse: () -> true
+
+      def flush_current_object: () -> void
+
+      def parse_one: () -> void
+
+      FIELD_LIST_HEADING: ::Regexp
+
+      def detect_field_list: () -> void
+
+      def process_field_list: (String obj, Integer at) -> void
+
+      def process_text_blocks: () -> void
+
+      def span: (String text) -> { type: :span, value: String }
+
+      def process_text_block: (String text) -> void
+
+      COMMENT_METHOD_REF_REGEXP: ::Regexp
+
+      def extract_method_reference: (String text) ->replacement_object?
+
+      COMMENT_SYMBOL_REGEXP: ::Regexp
+
+      def extract_symbol: (untyped text) -> replacement_object?
+
+      CAMELCASE_IDENTIFIER_REGEXP: ::Regexp
+
+      def extract_camelcase_identifier: (untyped text) -> replacement_object?
+
+      VISIBILITY_INDICATOR_REGEXP: ::Regexp
+
+      def process_visibility: (?untyped? obj) -> void
+
+      def process_code_examples: () -> void
+
+      def join_code_example_lines: (Integer start_at, Integer end_at) -> void
+
+      def normalize_tree: () -> void
+    end
+  end
+end

data/sig/docrb/parser/constant.rbs

@@ -0,0 +1,15 @@
+module Docrb
+  class Parser
+    class Constant
+      attr_reader name: String
+      attr_reader location: Location
+      attr_accessor parent: untyped
+
+      @object_id: Integer
+
+      def initialize: (Parser parser, Container parent, untyped node) -> void
+
+      def id: () -> Integer
+    end
+  end
+end

data/sig/docrb/parser/container.rbs

@@ -0,0 +1,91 @@
+module Docrb
+  class Parser
+    class Container
+      type visibility = :public | :protected | :private | :module_function
+
+      attr_accessor parent: Container?
+      attr_accessor parser: Parser
+      attr_accessor classes: NodeArray[Class]
+      attr_accessor modules: NodeArray[Module]
+      attr_accessor instance_methods: NodeArray[Method]
+      attr_accessor class_methods: NodeArray[Method]
+      attr_accessor extends: NodeArray[Reference]
+      attr_accessor includes: NodeArray[Reference]
+      attr_accessor name: String | Symbol
+      attr_accessor path_segments: Array[Symbol]?
+      attr_accessor instance_attributes: Array[Attribute]
+      attr_accessor class_attributes: Array[Attribute]
+      attr_accessor current_visibility_modifier: visibility
+      attr_accessor constants: NodeArray[Constant]
+      attr_accessor location: Location
+
+      @object_id: Integer
+      @node: untyped
+      @explicit_instance_visibility: Hash[Symbol, visibility]
+      @explicit_class_visibility: Hash[Symbol, visibility]
+      @defined_by: Array[Location]
+      @inside_module_function: bool
+      @default_constructor_visibility: visibility?
+
+      SINGLETON_CLASS_TYPES: ::Array[:singleton_class_node | :deferred_singleton_class_node]
+
+      def initialize: (Parser parser, Container? parent, untyped node) -> void
+
+      def extract_references: (NodeArray[untyped] from, Symbol attr) -> NodeArray[untyped]
+
+      def unowned_classes: () -> NodeArray[Class]
+
+      def all_classes: () -> NodeArray[Class]
+
+      def unowned_modules: () -> NodeArray[Module]
+
+      def all_modules: () -> NodeArray[Module]
+
+      def unowned_instance_methods: () -> NodeArray[Method]
+
+      def all_instance_methods: () -> NodeArray[Method]
+
+      def unowned_class_methods: () -> NodeArray[Method]
+
+      def all_class_methods: () -> NodeArray[Method]
+
+      def unowned_class_attributes: () -> NodeArray[Attribute]
+
+      def all_class_attributes: () -> NodeArray[Attribute]
+
+      def unowned_instance_attributes: () -> NodeArray[Attribute]
+
+      def all_instance_attributes: () -> NodeArray[Attribute]
+
+      def id: () -> Integer
+
+      def handle_parsed_node: (Parser parser, untyped node) -> nil
+
+      def instance_method_added: (Parser parser, untyped node, Method method) -> nil
+
+      def class_method_added: (Parser parser, untyped node, Method method) -> nil
+
+      def class_added: (Parser parser, untyped node, Method method) -> nil
+
+      def module_added: (Parser parser, untyped node, Method method) -> nil
+
+      def handle_call: (Call call) -> untyped
+
+      def handle_node: (untyped node) -> untyped
+
+      def parse_node: (untyped node) -> untyped
+
+      def reference: (Symbol | Array[Symbol] path) -> Reference
+
+      def add_attribute: (Parser parser, untyped node, Attribute::kind `type`) -> void
+
+      def adjust_split_attributes!: (Symbol scope) -> void
+
+      def handle_visibility_modifier: (Parser _parser, untyped node) -> void
+
+      def handle_singleton_visibility_modifier: (Parser _parser, untyped node) -> void
+
+      def update_constructor_visibility!: () -> void
+    end
+  end
+end

data/sig/docrb/parser/deferred_singleton_class.rbs

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+module Docrb
+  class Parser
+    class DeferredSingletonClass < Class
+      attr_reader target: Array[Symbol]
+
+      def kind: () -> :deferred_singleton_class
+
+      def initialize: (Parser parser, Container? parent, untyped node) -> void
+    end
+  end
+end

data/sig/docrb/parser/location.rbs

@@ -0,0 +1,24 @@
+module Docrb
+  class Parser
+    class Location
+
+
+      @virtual: untyped
+
+      attr_reader line_start: Integer?
+      attr_reader line_end: Integer?
+      attr_reader source: String?
+      attr_reader offset_start: Integer?
+      attr_reader offset_end: Integer?
+      attr_reader parser: Parser
+      attr_reader file_path: String?
+      attr_reader ast: untyped
+
+      def virtual?: -> bool
+
+      def initialize: (Parser parser, untyped ast, untyped loc) -> void
+
+      def load_source!: () -> void
+    end
+  end
+end

data/sig/docrb/parser/method.rbs

@@ -0,0 +1,34 @@
+module Docrb
+  class Parser
+    class Method
+      type method_type = :instance | :class
+
+      attr_accessor name: Symbol
+      attr_accessor parameters: MethodParameters
+      attr_accessor visibility: Container::visibility
+      attr_accessor overriding: Integer?
+      attr_accessor overridden_by: ::Array[Integer]
+      attr_accessor type: method_type
+      attr_accessor external_receiver: Reference?
+      attr_accessor location: Location
+      attr_accessor parent: Container?
+      attr_accessor node: untyped
+
+      @object_id: Integer
+
+      def kind: () -> :method
+
+      def initialize: (Parser parser, Container? parent, untyped node) -> void
+
+      def id: () -> Integer
+
+      def class?: () -> bool
+
+      def instance?: () -> bool
+
+      def module_function?: () -> bool
+
+      def external?: () -> bool
+    end
+  end
+end

data/sig/docrb/parser/method_parameters.rbs

@@ -0,0 +1,34 @@
+module Docrb
+  class Parser
+    class MethodParameters < Array[Parameter]
+      def initialize: (Parser parser, Method parent, untyped node) -> void
+
+      def id: () -> Integer
+
+      class Parameter
+        attr_reader parser: Parser
+        type kind = :arg | :kw | :optarg | :optkw | :rest | :kwrest | :block
+
+        def initialize: (Parser parser, kind kind, Symbol name, ?untyped? value) -> void
+
+        def id: () -> Integer
+
+        def has_value?: () -> bool
+
+        def optional?: () -> bool
+
+        def positional?: () -> bool
+
+        def keyword?: () -> bool
+
+        def block?: () -> bool
+
+        def rest?: () -> bool
+
+        private
+
+        def name_by_type: () -> Symbol
+      end
+    end
+  end
+end

data/sig/docrb/parser/module.rbs

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+module Docrb
+  class Parser
+    class Module < Container
+      def kind: () -> :module
+
+      def initialize: (Parser parser, Container? parent, untyped node) -> void
+
+      def instance_method_added: (Parser parser, untyped node, Method method) -> void
+
+      def handle_parsed_node: (Parser parser, untyped node) -> void
+    end
+  end
+end

data/sig/docrb/parser/node_array.rbs

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+module Docrb
+  class Parser
+    class NodeArray[unchecked out Elem] < Array[Elem]
+      def by_kind: (Symbol kind) -> ::Array[Elem]
+
+      def named: (Symbol name) -> ::Array[Elem]
+
+      def named!: (Symbol name) -> Elem
+    end
+  end
+end

data/sig/docrb/parser/reference.rbs

@@ -0,0 +1,19 @@
+module Docrb
+  class Parser
+    class Reference
+      attr_accessor parent: untyped
+      attr_accessor path: Array[Symbol]
+      attr_accessor resolved: ResolvedReference
+
+      @parser: Parser
+
+      def initialize: (Parser parser, untyped parent, Array[Symbol] path) -> void
+
+      def resolved?: () -> bool
+
+      def fulfilled?: () -> bool
+
+      def dereference!: () -> untyped
+    end
+  end
+end

data/sig/docrb/parser/reloader.rbs

@@ -0,0 +1,7 @@
+module Docrb
+  class Parser
+    class Reloader
+      def self.reload!: () -> true
+    end
+  end
+end

data/sig/docrb/parser/resolved_reference.rbs

@@ -0,0 +1,22 @@
+module Docrb
+  class Parser
+    class ResolvedReference
+      type reference_status = :valid | :broken
+
+      attr_accessor status: reference_status
+
+      @parser: Parser
+      @object_id: Integer
+
+      def initialize: (Parser parser, reference_status status, Integer id) -> void
+
+      def id: () -> Integer
+
+      def broken?: () -> bool
+
+      def valid?: () -> bool
+
+      def dereference!: () -> untyped
+    end
+  end
+end

data/sig/docrb/parser/virtual_method.rbs

@@ -0,0 +1,17 @@
+module Docrb
+  class Parser
+    class VirtualMethod
+      VirtualReceiver: untyped
+
+      attr_accessor name: Symbol | String
+
+      attr_accessor parameters: ::Array[untyped]
+
+      attr_accessor receiver: untyped
+
+      def type: () -> :def_node
+
+      def initialize: (Symbol | String name, untyped receiver, ?::Array[untyped]? parameters) -> void
+    end
+  end
+end

data/sig/docrb/parser.rbs

@@ -0,0 +1,5 @@
+module Docrb
+  class Parser
+    VERSION: String
+  end
+end