holistic-ruby 0.1.0

data/lib/holistic/language_server/stdio/parser.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Holistic::LanguageServer
+  class Stdio::Parser
+    def initialize
+      @buffer = ::String.new
+      @overflow_from_previous_ingestion = ::String.new
+      @in_header = true
+      @content_length = 0
+    end
+
+    def ingest(payload)
+      payload.each_char do |char|
+        if @in_header || !completed?
+          @buffer.concat(char)
+        else
+          @overflow_from_previous_ingestion.concat(char)
+        end
+
+        if @in_header
+          prepare_to_parse_message! if @buffer.end_with?(Protocol::END_OF_HEADER)
+        end
+      end
+    end
+
+    def completed?
+      !@in_header && @content_length == @buffer.length
+    end
+
+    def message
+      Message.new(::JSON.parse(@buffer))
+    end
+
+    def clear
+      left_over = @overflow_from_previous_ingestion.dup
+      @overflow_from_previous_ingestion.clear
+
+      @buffer.clear
+      @in_header = true
+      @content_length = 0
+
+      ingest(left_over) if !left_over.empty?
+    end
+
+    private
+
+    MissingContentLengthHeaderError = ::Class.new(::StandardError)
+
+    def prepare_to_parse_message!
+      @buffer.each_line do |line|
+        key, value = line.split(":").map(&:strip)
+
+        if key == Protocol::CONTENT_LENGTH_HEADER
+          @in_header = false
+          @content_length = Integer(value)
+          @buffer.clear
+
+          return
+        end
+      end
+
+      raise MissingContentLengthHeaderError, @buffer
+    end
+  end
+end

data/lib/holistic/language_server/stdio/server.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Holistic::LanguageServer::Stdio
+  class Server
+    def initialize(input = STDIN, output = STDOUT)
+      @input = input
+      @output = output
+      @stopped = false
+      @on_data_received = -> { raise ::NotImplementedError }
+
+      set_output_to_binary_mode!
+    end
+
+    def start_input_loop(&block)
+      @on_data_received = block
+
+      read_input until @stopped
+    end
+
+    def write_to_output(payload)
+      @output.write(payload)
+      @output.flush
+    end
+
+    def stop!
+      @stopped = true
+    end
+
+    private
+
+    def set_output_to_binary_mode!
+      @output.binmode
+    end
+
+    def read_input
+      begin
+        @input.flush
+        payload = @input.sysread(255)
+        
+        @on_data_received.call(payload)
+      rescue ::EOFError, ::IOError, ::Errno::ECONNRESET, ::Errno::ENOTSOCK
+        @stopped = true
+      end
+    end
+  end
+end

data/lib/holistic/language_server/stdio/start.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Holistic::LanguageServer
+  module Stdio::Start
+    extend self
+
+    def call
+      ::Holistic.logger.info("starting holistic-ruby server on dir: #{::Dir.getwd}")
+
+      start_language_server_lifecycle!
+
+      server = Stdio::Server.new
+      parser = Stdio::Parser.new
+      
+      server.start_input_loop do |payload|
+        parser.ingest(payload)
+
+        while parser.completed?
+          response = ::Holistic::LanguageServer::Router.dispatch(parser.message)
+
+          case response
+          in Response::Success  then server.write_to_output(response.encode)
+          in Response::Error    then server.write_to_output(response.encode)
+          in Response::NotFound then nil
+          in Response::Drop     then nil
+          in Response::Exit     then server.stop!
+          end
+          
+          parser.clear
+        end
+      end
+
+      ::Holistic.logger.info("closing holistic-ruby server on dir #{::Dir.getwd}")
+    rescue ::StandardError => err
+      ::Holistic.logger.info("crash from Stdio::Start")
+      ::Holistic.logger.info(err.inspect)
+      ::Holistic.logger.info(err.backtrace)
+
+      raise err
+    end
+
+    private
+
+    def start_language_server_lifecycle!
+      ::Holistic::LanguageServer::Current.lifecycle = ::Holistic::LanguageServer::Lifecycle.new
+    end
+  end
+end

data/lib/holistic/ruby/autocompletion/suggest.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Holistic::Ruby::Autocompletion
+  module Suggest
+    extend self
+
+    Suggestion = ::Data.define(:code, :kind)
+
+    def call(code:, scope:)
+      lookup_scope = scope
+
+      if code.start_with?("::")
+        lookup_scope = lookup_scope.parent until lookup_scope.root?
+      end
+
+      suggest_namespaces_from_scope(code:, scope: lookup_scope)
+    end
+
+    private
+
+    NonMethods = ->(scope) { !scope.method? }
+
+    def suggest_namespaces_from_scope(code:, scope:)
+      suggestions = []
+
+      partial_namespaces = code.split(/(::)/).compact_blank
+      namespace_to_autocomplete = partial_namespaces.pop.then { _1 == "::" ? "" : _1 }
+      namespaces_to_resolve = partial_namespaces.reject { _1 == "::" }
+
+      namespaces_to_resolve.each do |namespace_name|
+        scope = resolve_scope(name: namespace_name, from_scope: scope)
+
+        return suggestions if scope.nil?
+      end
+
+      # special case when user did not type :: at the end but the current word
+      # is matches an existing namespace. In this case, suggestions will start with ::.
+      # For example:
+      #
+      #                          \/ cursor here
+      # typing: "::MyApp::Payments"
+      # suggestions: ["::Record", "::SendReminder"]
+      resolve_scope(name: namespace_to_autocomplete, from_scope: scope)&.then do |fully_typed_scope|
+        scope = fully_typed_scope
+        namespace_to_autocomplete = ""
+      end
+
+      should_search_upwards = namespaces_to_resolve.empty?
+
+      search = ->(scope) do
+        scope.children.filter(&NonMethods).each do |child_scope|
+          if child_scope.name.start_with?(namespace_to_autocomplete)
+            suggestions << Suggestion.new(code: child_scope.name, kind: child_scope.kind)
+          end
+        end
+
+        search.(scope.parent) if scope.parent.present? && should_search_upwards
+      end
+
+      search.(scope)
+
+      suggestions
+    end
+
+    def resolve_scope(name:, from_scope:)
+      resolved_scope = from_scope.children.find { |scope| scope.name == name }
+
+      if resolved_scope.nil? && from_scope.parent.present?
+        resolved_scope = resolve_scope(name:, from_scope: from_scope.parent)
+      end
+
+      resolved_scope
+    end
+  end
+end

data/lib/holistic/ruby/parser/constant_resolution.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Holistic::Ruby::Parser
+  class ConstantResolution
+    attr_reader :scope_repository, :scope
+
+    def initialize(scope_repository:, root_scope:)
+      @scope_repository = scope_repository
+      @scope = root_scope
+      @constant_resolution_possibilities = ["::"]
+    end
+
+    def current
+      @constant_resolution_possibilities.dup
+    end
+
+    def register_child_module(nesting:, location:, &block)
+      starting_scope = @scope
+
+      nesting.each do |name|
+        @scope =
+          ::Holistic::Ruby::Scope::Register.call(
+            repository: @scope_repository,
+            parent: @scope,
+            kind: ::Holistic::Ruby::Scope::Kind::MODULE,
+            name:,
+            location:
+          )
+      end
+
+      @constant_resolution_possibilities.unshift(@scope.fully_qualified_name)
+
+      block.call
+
+      @scope = starting_scope
+      @constant_resolution_possibilities.shift
+    end
+
+    def register_child_class(nesting:, location:, &block)
+      starting_scope = @scope
+
+      nesting.each do |name|
+        @scope =
+          ::Holistic::Ruby::Scope::Register.call(
+            repository: @scope_repository,
+            parent: @scope,
+            kind: ::Holistic::Ruby::Scope::Kind::CLASS,
+            name:,
+            location:
+          )
+      end
+
+      @constant_resolution_possibilities.unshift(@scope.fully_qualified_name)
+
+      block.call
+
+      @scope = starting_scope
+      @constant_resolution_possibilities.shift
+    end
+  end
+end

data/lib/holistic/ruby/parser/live_editing/process_file_changed.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Holistic::Ruby::Parser
+  module LiveEditing::ProcessFileChanged
+    extend self
+
+    def call(application:, file:)
+      references_to_recalculate = identify_references_to_recalculate_type_inference(application:, file:)
+
+      unregister_scopes_in_file(application:, file:)
+      unregsiter_references_in_file(application:, file:)
+
+      parse_again(application:, file:)
+
+      recalculate_type_inference_for_references(application:, references: references_to_recalculate)
+    end
+
+    private
+
+    def identify_references_to_recalculate_type_inference(application:, file:)
+      # we need to reject references declared in the same because they're already going to be
+      # unregistered and reparsed. If we don't do that, we'll end up with duplicated reference records. 
+
+      application.references
+        .list_references_to_scopes_in_file(scopes: application.scopes, file_path: file.path)
+        .reject { _1.location.file_path == file.path }
+    end
+
+    def unregister_scopes_in_file(application:, file:)
+      application.scopes.list_scopes_in_file(file.path).each do |scope|
+        ::Holistic::Ruby::Scope::Unregister.call(
+          repository: application.scopes,
+          fully_qualified_name: scope.fully_qualified_name,
+          file_path: file.path
+        )
+      end
+    end
+
+    def unregsiter_references_in_file(application:, file:)
+      application.references.list_references_in_file(file.path).each do |reference|
+        ::Holistic::Ruby::Reference::Unregister.call(
+          repository: application.references,
+          reference: reference
+        )
+      end
+    end
+
+    def parse_again(application:, file:)
+      ParseFile.call(application:, file:)
+
+      ::Holistic::Ruby::TypeInference::SolvePendingReferences.call(application:)
+    end
+
+    def recalculate_type_inference_for_references(application:, references:)
+      references.each do |reference|
+        reference.conclusion = ::Holistic::Ruby::TypeInference::Conclusion.pending
+
+        ::Holistic::Ruby::TypeInference::Solve.call(application:, reference:)
+      end
+    end
+  end
+end

data/lib/holistic/ruby/parser/nesting_syntax.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Holistic::Ruby::Parser
+  class NestingSyntax
+    attr_reader :value, :is_root_scope
+
+    def self.build(node)
+      nesting_syntax = NestingSyntax.new
+
+      append = ->(node) do
+        case node
+        when ::SyntaxTree::ConstRef     then nesting_syntax << node.child_nodes[0].value
+        when ::SyntaxTree::VarField     then nesting_syntax << node.child_nodes.first.value
+        when ::SyntaxTree::Const        then nesting_syntax << node.value
+        when ::SyntaxTree::VCall        then append.(node.child_nodes.first)
+        when ::SyntaxTree::Ident        then nesting_syntax << node.value
+        when ::SyntaxTree::IVar         then nesting_syntax << node.value
+        when ::SyntaxTree::Period       then nesting_syntax << "."
+        when ::SyntaxTree::Paren        then append.(node.child_nodes[1])       # node.child_nodes[0] is ::SyntaxTree::LParen
+        when ::SyntaxTree::ARef         then append.(node.child_nodes.first)    # not sure what to do here e.g. `ActiveRecord::Migration[7.0]`
+        when ::SyntaxTree::CallNode     then node.child_nodes.each(&append)
+        when ::SyntaxTree::IfOp         then nesting_syntax << "[conditional]"  # not sure what tod o here
+        when ::SyntaxTree::VarRef       then node.child_nodes.each(&append)
+        when ::SyntaxTree::ConstPathRef then node.child_nodes.each(&append)
+        when ::SyntaxTree::Statements   then node.child_nodes.each(&append)
+        when ::SyntaxTree::TopConstRef  then nesting_syntax.mark_as_root_scope! and node.child_nodes.each(&append)
+        # else pp(original_node) and pp(Current.file.path) and raise "Unexpected node type: #{node.class}"
+        end
+      end
+
+      append.(node)
+
+      nesting_syntax
+    end
+
+    def initialize(value = [])
+      @value = Array(value)
+      @is_root_scope = false
+    end
+
+    def mark_as_root_scope!
+      @is_root_scope = true
+    end
+
+    def supported?
+      @value.any?
+    end
+
+    def unsupported?
+      !supported?
+    end
+
+    def root_scope_resolution?
+      is_root_scope
+    end
+
+    def constant?
+      return false if unsupported?
+
+      @value.last[0].then { _1 == _1.upcase }
+    end
+
+    def to_s
+      @value.join("::")
+    end
+
+    def eql?(other)
+      other.class == self.class && other.to_s == to_s
+    end
+
+    alias == eql?
+
+    delegate :each, to: :value
+    delegate :<<,   to: :value
+  end
+end

data/lib/holistic/ruby/parser/program_visitor.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+module Holistic::Ruby::Parser
+  class ProgramVisitor < ::SyntaxTree::Visitor
+    attr_reader :application, :file
+
+    def initialize(application:, constant_resolution:, file:)
+      @application = application
+      @constant_resolution = constant_resolution
+      @file = file
+
+      super()
+    end
+
+    visit_methods do
+      def visit_module(node)
+        declaration_node, body_node = node.child_nodes
+
+        nesting = NestingSyntax.build(declaration_node)
+        location = build_scope_location(declaration_node:, body_node:)
+
+        @constant_resolution.register_child_module(nesting:, location:) do
+          visit(body_node)
+        end
+      end
+
+      def visit_class(node)
+        declaration_node, superclass_node, body_node = node.child_nodes
+
+        if superclass_node
+          register_reference(nesting: NestingSyntax.build(superclass_node), location: build_location(superclass_node))
+        end
+
+        nesting = NestingSyntax.build(declaration_node)
+        location = build_scope_location(declaration_node:, body_node:)
+
+        @constant_resolution.register_child_class(nesting:, location:) do
+          visit(body_node)
+        end
+      end
+
+      def visit_def(node)
+        instance_node, period_node, method_name_node, _params, body_node = node.child_nodes
+
+        method_name =
+          if instance_node.present? && period_node.present?
+            instance_node.child_nodes.first.value + period_node.value + method_name_node.value
+          else
+            method_name_node.value
+          end
+
+        location = build_scope_location(declaration_node: method_name_node, body_node:)
+
+        ::Holistic::Ruby::Scope::Register.call(
+          repository: @application.scopes,
+          parent: @constant_resolution.scope,
+          kind: ::Holistic::Ruby::Scope::Kind::METHOD,
+          name: method_name,
+          location:
+        )
+
+        visit(body_node)
+      end
+
+      def visit_vcall(node)
+        method_call_clue = ::Holistic::Ruby::TypeInference::Clue::MethodCall.new(
+          nesting: nil,
+          method_name: node.child_nodes.first.value,
+          resolution_possibilities: @constant_resolution.current
+        )
+
+        ::Holistic::Ruby::Reference::Register.call(
+          repository: @application.references,
+          scope: @constant_resolution.scope,
+          clues: [method_call_clue],
+          location: build_location(node)
+        )
+      end
+
+      def visit_call(node)
+        instance_node, _period_node, method_name_node, arguments_nodes = node.child_nodes
+
+        visit(instance_node)
+        visit(arguments_nodes)
+
+        nesting =
+          if instance_node.is_a?(::SyntaxTree::CallNode)
+            NestingSyntax.build(instance_node.child_nodes[2])
+          elsif instance_node.present?
+            NestingSyntax.build(instance_node)
+          else
+            nil
+          end
+
+        return if nesting.present? && nesting.unsupported?
+
+        # method_name_node is nil for the syntax `DoSomething.(value)`
+        method_name = method_name_node.nil? ? "call" : method_name_node.value
+        
+        method_call_clue = ::Holistic::Ruby::TypeInference::Clue::MethodCall.new(
+          nesting:,
+          method_name:,
+          resolution_possibilities: @constant_resolution.current
+        )
+
+        ::Holistic::Ruby::Reference::Register.call(
+          repository: @application.references,
+          scope: @constant_resolution.scope,
+          clues: [method_call_clue],
+          location: build_location(method_name_node || instance_node)
+        )
+      end
+
+      def visit_assign(node)
+        assign_node, body_node = node.child_nodes
+
+        if !assign_node.child_nodes.first.is_a?(::SyntaxTree::Const)
+          visit(body_node)
+
+          return # TODO
+        end
+
+        # Are we assigning to something that opens a block? If so, we need to register the child scope
+        # and visit the statements. This is needed to support methods defined in `Data.define` and `Struct.new`.
+        if body_node.is_a?(::SyntaxTree::MethodAddBlock)
+          call_node, block_node = body_node.child_nodes
+
+          nesting = NestingSyntax.build(assign_node)
+          location = build_scope_location(declaration_node: assign_node, body_node: block_node)
+
+          @constant_resolution.register_child_class(nesting:, location:) do
+            visit(block_node)
+          end
+
+          return
+        end
+
+        location = build_scope_location(declaration_node: assign_node, body_node:)
+
+        ::Holistic::Ruby::Scope::Register.call(
+          repository: @application.scopes,
+          parent: @constant_resolution.scope,
+          kind: ::Holistic::Ruby::Scope::Kind::LAMBDA,
+          name: assign_node.child_nodes.first.value,
+          location:
+        )
+
+        visit(body_node)
+      end
+
+      def visit_const_path_ref(node)
+        register_reference(nesting: NestingSyntax.build(node), location: build_location(node))
+      end
+
+      def visit_top_const_ref(node)
+        register_reference(nesting: NestingSyntax.build(node), location: build_location(node))
+      end
+
+      def visit_const(node)
+        register_reference(nesting: NestingSyntax.build(node), location: build_location(node))
+      end
+    end
+
+    private
+
+    def register_reference(nesting:, location:)
+      clue = ::Holistic::Ruby::TypeInference::Clue::ScopeReference.new(
+        nesting:,
+        resolution_possibilities: @constant_resolution.current
+      )
+
+      ::Holistic::Ruby::Reference::Register.call(
+        repository: @application.references,
+        scope: @constant_resolution.scope,
+        clues: [clue],
+        location:
+      )
+    end
+
+    def build_scope_location(declaration_node:, body_node:)
+      ::Holistic::Ruby::Scope::Location.new(
+        declaration: build_location(declaration_node),
+        body: build_location(body_node)
+      )
+    end
+
+    def build_location(node)
+      # https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#position
+      offset_to_match_language_server_zero_based_position = 1
+
+      start_line   = node.location.start_line - offset_to_match_language_server_zero_based_position
+      end_line     = node.location.end_line - offset_to_match_language_server_zero_based_position
+      start_column = node.location.start_column
+      end_column   = node.location.end_column
+
+      # syntax_tree seems to have a bug with the bodystmt node.
+      # It sets the end_column lower than the start_column.
+      if start_line == end_line && start_column > end_column
+        start_column, end_column = end_column, start_column
+      end
+
+      ::Holistic::Document::Location.new(file_path: file.path, start_line:, start_column:, end_line:, end_column:)
+    end
+  end
+end

data/lib/holistic/ruby/parser/table_of_contents.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Holistic::Ruby::Parser
+  # TODO: move to an attibute of the scope
+  class TableOfContents
+    attr_reader :records
+
+    def initialize
+      @records = Hash.new { |hash, key| hash[key] = {} }
+    end
+
+    def register(scope:, name:, clue:)
+      @records[scope.fully_qualified_name][name] ||= []
+      @records[scope.fully_qualified_name][name] << clue
+    end
+  end
+end

data/lib/holistic/ruby/parser.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Holistic::Ruby::Parser
+  ParseFile = ->(application:, file:) do
+    program = ::SyntaxTree.parse(file.read)
+
+    constant_resolution = ConstantResolution.new(
+      scope_repository: application.scopes,
+      root_scope: application.root_scope
+    )
+
+    visitor = ProgramVisitor.new(application:, constant_resolution:, file:)
+
+    visitor.visit(program)
+  rescue ::SyntaxTree::Parser::ParseError
+    ::Holistic.logger.info("syntax error on file #{file.path}")
+  end
+
+  ParseDirectory = ->(application:, directory_path:) do
+    ::Dir.glob("#{directory_path}/**/*.rb").map do |file_path|
+      file = ::Holistic::Document::File.new(path: file_path)
+
+      ParseFile[application:, file:]
+    end
+  end
+end