holistic-ruby 0.1.1 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 601bd799099f6615186f5d70dafab227a2f5d59e556aedec607784fc289b9f23
-  data.tar.gz: 8684f179e1cf58b47d4cac81c75c10113c46f5578a9ab1ecd74eddcad2e20259
+  metadata.gz: abe4144d1f581c6151784152792604f799c0140d62c28f445f377f6039c40457
+  data.tar.gz: 6593b92046a8087f75c171280ae66401ff0bb1eb0f6dba9fa496df127bb39ee8
 SHA512:
-  metadata.gz: 6cc033aaddc4b86f6b733c17c7cea974fabcc68132b7f7776dcbe9bdf4f6222ed52d6e58694e9988d624b693eab3d6abcf28389d5208b41221fee511e33c486e
-  data.tar.gz: 54ebf824ec6771d1b58146a6c958a9271e229daa5c2d0c3a23830a873be8ffc523065f06a0240d821256712dd2c31c7136a7bf6e38fb7552eab4124bec24b5c8
+  metadata.gz: eb1f43eaa7f78c334da3f8d8f2fc782bfa662b94f8a5a6b5a8a24ab271cae26d62703bd722860dbecf637d9aae5d4595d1424257406d9d349f0d90a95ab702d4
+  data.tar.gz: f42ed13efc65779f8ef175c7127d03cf68bebd5df990a1744d714100efe639cad104b55592507d4737ecfa4d48e75d6b69da194a033f056740a16fde8bf3d65d

data/README.md

@@ -32,4 +32,4 @@
 
 ## Why is it a toy language server?
 
-I use `holistic-ruby` on a daily basis in a faily large Ruby codebase. It seems stable and speedy. But... I built it for myself and I'm the only one using it :smile:
+I use `holistic-ruby` on a daily basis while working in a fairly large Ruby codebase. It seems stable and speedy. But... I built it for myself and I'm the only one using it :smile:

data/lib/holistic/extensions/events.rb

@@ -5,6 +5,14 @@ class Holistic::Extensions::Events
     resolve_method_call_known_scope: {
       params: [:reference, :referenced_scope, :method_call_clue],
       output: ::Holistic::Ruby::Scope::Record
+    },
+    class_scope_registered: {
+      params: [:class_scope, :location],
+      output: nil
+    },
+    lambda_scope_registered: {
+      params: [:lambda_scope, :location],
+      output: nil
     }
   }.freeze
 
@@ -30,7 +38,7 @@ class Holistic::Extensions::Events
 
     result = @listeners[event].lazy.filter_map { |callback| callback.call(params) }.first
 
-    raise UnexpectedOutput, result if result.present? && !result.is_a?(expected_output)
+    raise UnexpectedOutput, result if expected_output.present? && result.present? && !result.is_a?(expected_output)
 
     result
   end

data/lib/holistic/extensions/ruby/stdlib.rb

@@ -16,28 +16,42 @@ module Holistic::Extensions::Ruby
       nil
     end
 
-    ResolveStaticMethods = ->(application, params) do
-      method_call_clue, referenced_scope = params[:method_call_clue], params[:referenced_scope]
-
-      self_method_name = "#{referenced_scope.fully_qualified_name}#self.#{method_call_clue.method_name}"
-
-      application.scopes.find_by_fully_qualified_name(self_method_name)
+    RegisterClassConstructor = ->(application, params) do
+      class_scope, location = params[:class_scope], params[:location]
+
+      has_overridden_new_method = class_scope.children.find { _1.class_method? && _1.name == "new" }
+
+      unless has_overridden_new_method
+        ::Holistic::Ruby::Scope::Register.call(
+          repository: application.scopes,
+          parent: class_scope,
+          kind: ::Holistic::Ruby::Scope::Kind::CLASS_METHOD,
+          name: "new",
+          location:
+        )
+      end
     end
 
-    LAMBDA_METHODS = ["call", "curry"]
+    LAMBDA_METHODS = ["call", "curry"].freeze
 
-    ResolveCallToLambda = ->(application, params) do
-      method_call_clue, referenced_scope = params[:method_call_clue], params[:referenced_scope]
+    RegisterLambdaMethods = ->(application, params) do
+      lambda_scope, location = params[:lambda_scope], params[:location]
 
-      if LAMBDA_METHODS.include?(method_call_clue.method_name) && referenced_scope.lambda?
-        return referenced_scope
+      LAMBDA_METHODS.each do |method_name|
+        ::Holistic::Ruby::Scope::Register.call(
+          repository: application.scopes,
+          parent: lambda_scope,
+          kind: ::Holistic::Ruby::Scope::Kind::CLASS_METHOD,
+          name: method_name,
+          location:
+        )
       end
     end
 
     def register(application)
       application.extensions.bind(:resolve_method_call_known_scope, &ResolveClassConstructor.curry[application])
-      application.extensions.bind(:resolve_method_call_known_scope, &ResolveStaticMethods.curry[application])
-      application.extensions.bind(:resolve_method_call_known_scope, &ResolveCallToLambda.curry[application])
+      application.extensions.bind(:class_scope_registered,          &RegisterClassConstructor.curry[application])
+      application.extensions.bind(:lambda_scope_registered,         &RegisterLambdaMethods.curry[application])
     end
   end
 end

data/lib/holistic/language_server/requests/text_document/completion.rb

@@ -19,10 +19,11 @@ module Holistic::LanguageServer
       end
 
       code = document.expand_code(cursor)
-      scope = request.application.scopes.find_inner_most_scope_by_cursor(cursor) || request.application.root_scope
-
+      
       return request.respond_with(nil) if code.blank?
 
+      scope = request.application.scopes.find_inner_most_scope_by_cursor(cursor) || request.application.root_scope
+
       suggestions = ::Holistic::Ruby::Autocompletion::Suggest.call(code:, scope:)
 
       respond_with_suggestions(request, suggestions)
@@ -40,11 +41,12 @@ module Holistic::LanguageServer
 
     module CompletionKind
       FROM_SCOPE_TO_COMPLETION = {
-        ::Holistic::Ruby::Scope::Kind::CLASS  => Protocol::COMPLETION_ITEM_KIND_CLASS,
-        ::Holistic::Ruby::Scope::Kind::LAMBDA => Protocol::COMPLETION_ITEM_KIND_FUNCTION,
-        ::Holistic::Ruby::Scope::Kind::METHOD => Protocol::COMPLETION_ITEM_KIND_METHOD,
-        ::Holistic::Ruby::Scope::Kind::MODULE => Protocol::COMPLETION_ITEM_KIND_MODULE,
-        ::Holistic::Ruby::Scope::Kind::ROOT   => Protocol::COMPLETION_ITEM_KIND_MODULE
+        ::Holistic::Ruby::Scope::Kind::CLASS           => Protocol::COMPLETION_ITEM_KIND_CLASS,
+        ::Holistic::Ruby::Scope::Kind::LAMBDA          => Protocol::COMPLETION_ITEM_KIND_FUNCTION,
+        ::Holistic::Ruby::Scope::Kind::CLASS_METHOD    => Protocol::COMPLETION_ITEM_KIND_METHOD,
+        ::Holistic::Ruby::Scope::Kind::INSTANCE_METHOD => Protocol::COMPLETION_ITEM_KIND_METHOD,
+        ::Holistic::Ruby::Scope::Kind::MODULE          => Protocol::COMPLETION_ITEM_KIND_MODULE,
+        ::Holistic::Ruby::Scope::Kind::ROOT            => Protocol::COMPLETION_ITEM_KIND_MODULE
       }.freeze
 
       DEFAULT = Protocol::COMPLETION_ITEM_KIND_MODULE

data/lib/holistic/language_server/requests/text_document/did_close.rb

@@ -7,9 +7,7 @@ module Holistic::LanguageServer
     def call(request)
       path = Format::FileUri.extract_path(request.message.param("textDocument", "uri"))
 
-      unsaved_document = request.application.unsaved_documents.find(path)
-
-      if unsaved_document.present?
+      request.application.unsaved_documents.find(path)&.then do |unsaved_document|
         request.application.unsaved_documents.delete(path)
         
         if unsaved_document.has_unsaved_changes?

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

@@ -13,12 +13,42 @@ module Holistic::Ruby::Autocompletion
         lookup_scope = lookup_scope.parent until lookup_scope.root?
       end
 
-      suggest_namespaces_from_scope(code:, scope: lookup_scope)
+      if code.include?(".")
+        suggest_methods_from_scope(code:, scope: lookup_scope)
+      else
+        suggest_namespaces_from_scope(code:, scope: lookup_scope)
+      end
     end
 
     private
 
-    NonMethods = ->(scope) { !scope.method? }
+    NonMethods = ->(scope) { !Methods[scope] }
+    Methods    = ->(scope) { scope.instance_method? || scope.class_method? }
+
+    # Payment. <--
+    # Payment::Notifications. <--
+    # current_user.a
+    def suggest_methods_from_scope(code:, scope:)
+      suggestions = []
+
+      partial_namespaces = code.split(/(::|\.)/).compact_blank
+      method_to_autocomplete = partial_namespaces.pop.then { _1 == "." ? "" : _1 }
+      namespaces_to_resolve = partial_namespaces.reject { _1 == "::" || _1 == "." }
+
+      namespaces_to_resolve.each do |namespace_name|
+        scope = resolve_scope(name: namespace_name, from_scope: scope)
+
+        return suggestions if scope.nil?
+      end
+
+      scope.children.filter(&:class_method?).each do |method_scope|
+        if method_scope.name.start_with?(method_to_autocomplete)
+          suggestions << Suggestion.new(code: method_scope.name, kind: method_scope.kind)
+        end
+      end
+
+      suggestions
+    end
 
     def suggest_namespaces_from_scope(code:, scope:)
       suggestions = []

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

@@ -2,12 +2,18 @@
 
 module Holistic::Ruby::Parser
   class ConstantResolution
-    attr_reader :scope_repository, :scope
+    module MethodRegistrationMode
+      INSTANCE_METHODS = :instance_methods
+      CLASS_METHODS    = :class_methods
+    end
+
+    attr_reader :scope_repository, :scope, :method_registration_mode
 
     def initialize(scope_repository:, root_scope:)
       @scope_repository = scope_repository
       @scope = root_scope
       @constant_resolution_possibilities = ["::"]
+      @method_registration_mode = MethodRegistrationMode::INSTANCE_METHODS
     end
 
     def current
@@ -28,12 +34,17 @@ module Holistic::Ruby::Parser
           )
       end
 
+      registered_module_scope = @scope
+
       @constant_resolution_possibilities.unshift(@scope.fully_qualified_name)
 
       block.call
 
-      @scope = starting_scope
+      change_method_registration_mode_to_instance_methods!
       @constant_resolution_possibilities.shift
+      @scope = starting_scope
+
+      registered_module_scope
     end
 
     def register_child_class(nesting:, location:, &block)
@@ -50,12 +61,52 @@ module Holistic::Ruby::Parser
           )
       end
 
+      registered_class_scope = @scope
+
       @constant_resolution_possibilities.unshift(@scope.fully_qualified_name)
 
       block.call
 
-      @scope = starting_scope
+      change_method_registration_mode_to_instance_methods!
       @constant_resolution_possibilities.shift
+      @scope = starting_scope
+
+      registered_class_scope
+    end
+
+    def register_child_method(nesting:, location:, kind:, &block)
+      starting_scope = @scope
+
+      nesting.each do |name|
+        @scope =
+          ::Holistic::Ruby::Scope::Register.call(
+            repository: @scope_repository,
+            parent: @scope,
+            kind:,
+            name:,
+            location:
+          )
+      end
+
+      registered_method_scope = @scope
+
+      block.call
+
+      @scope = starting_scope
+
+      registered_method_scope
+    end
+
+    def method_registration_class_methods?
+      method_registration_mode == MethodRegistrationMode::CLASS_METHODS
+    end
+
+    def change_method_registration_mode_to_class_methods!
+      @method_registration_mode = MethodRegistrationMode::CLASS_METHODS
+    end
+
+    def change_method_registration_mode_to_instance_methods!
+      @method_registration_mode = MethodRegistrationMode::INSTANCE_METHODS
     end
   end
 end

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

@@ -5,7 +5,10 @@ module Holistic::Ruby::Parser
     extend self
 
     def call(application:, file:)
-      references_to_recalculate = identify_references_to_recalculate_type_inference(application:, file:)
+      # TODO: do not build the AST twice
+      return unless HasValidSyntax[file:]
+
+      references_to_recalculate = identify_references_to_recalculate(application:, file:)
 
       unregister_scopes_in_file(application:, file:)
       unregsiter_references_in_file(application:, file:)
@@ -17,9 +20,9 @@ module Holistic::Ruby::Parser
 
     private
 
-    def identify_references_to_recalculate_type_inference(application:, file:)
+    def identify_references_to_recalculate(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. 
+      # 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)

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

@@ -14,6 +14,7 @@ module Holistic::Ruby::Parser
         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::Kw           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

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

@@ -34,32 +34,43 @@ module Holistic::Ruby::Parser
         nesting = NestingSyntax.build(declaration_node)
         location = build_scope_location(declaration_node:, body_node:)
 
-        @constant_resolution.register_child_class(nesting:, location:) do
+        class_scope = @constant_resolution.register_child_class(nesting:, location:) do
           visit(body_node)
         end
+
+        @application.extensions.dispatch(:class_scope_registered, { class_scope:, location: })
+      end
+
+      def visit_command(node)
+        command_name_node, args_node = node.child_nodes
+
+        if command_name_node.value == "extend"
+          is_extending_self = args_node.child_nodes.size == 1 && NestingSyntax.build(args_node.child_nodes.first).to_s == "self"
+
+          @constant_resolution.change_method_registration_mode_to_class_methods! if is_extending_self
+        end
+
+        visit(args_node)
       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
-
+        nesting = NestingSyntax.new(method_name_node.value)
         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:
-        )
+        kind =
+          if instance_node.present? && instance_node.child_nodes.first.value == "self"
+            ::Holistic::Ruby::Scope::Kind::CLASS_METHOD
+          elsif @constant_resolution.method_registration_class_methods?
+            ::Holistic::Ruby::Scope::Kind::CLASS_METHOD
+          else
+            ::Holistic::Ruby::Scope::Kind::INSTANCE_METHOD
+          end
 
-        visit(body_node)
+        @constant_resolution.register_child_method(nesting:, location:, kind:) do
+          visit(body_node)
+        end
       end
 
       def visit_vcall(node)
@@ -128,22 +139,27 @@ module Holistic::Ruby::Parser
           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
+          class_scope = @constant_resolution.register_child_class(nesting:, location:) do
             visit(block_node)
           end
 
+          @application.extensions.dispatch(:class_scope_registered, { class_scope:, location: })
+
           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:
-        )
+        lambda_scope =
+          ::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:
+          )
+
+        @application.extensions.dispatch(:lambda_scope_registered, { lambda_scope:, location: })
 
         visit(body_node)
       end

data/lib/holistic/ruby/parser.rb

@@ -1,6 +1,14 @@
 # frozen_string_literal: true
 
 module Holistic::Ruby::Parser
+  HasValidSyntax = ->(file:) do
+    ::SyntaxTree.parse(file.read)
+
+    true
+  rescue ::SyntaxTree::Parser::ParseError
+    false
+  end
+
   ParseFile = ->(application:, file:) do
     program = ::SyntaxTree.parse(file.read)
 

data/lib/holistic/ruby/scope/kind.rb

@@ -2,10 +2,11 @@
 
 module Holistic::Ruby::Scope
   module Kind
-    ROOT   = :root
-    MODULE = :module
-    CLASS  = :class
-    METHOD = :method
-    LAMBDA = :lambda
+    ROOT            = :root
+    MODULE          = :module
+    CLASS           = :class
+    INSTANCE_METHOD = :instance_method
+    CLASS_METHOD    = :class_method
+    LAMBDA          = :lambda
   end
 end

data/lib/holistic/ruby/scope/record.rb

@@ -16,10 +16,10 @@ module Holistic::Ruby::Scope
       return "" if root?
 
       separator =
-        if kind == Kind::METHOD
-          "#"
-        else
-          "::"
+        case kind
+        when Kind::INSTANCE_METHOD then "#"
+        when Kind::CLASS_METHOD    then "."
+        else "::"
         end
 
       "#{parent.fully_qualified_name}#{separator}#{name}"
@@ -41,8 +41,12 @@ module Holistic::Ruby::Scope
       kind == Kind::MODULE
     end
 
-    def method?
-      kind == Kind::METHOD
+    def instance_method?
+      kind == Kind::INSTANCE_METHOD
+    end
+
+    def class_method?
+      kind == Kind::CLASS_METHOD
     end
 
     def descendant?(other)

data/lib/holistic/ruby/type_inference/solve.rb

@@ -37,7 +37,12 @@ module Holistic::Ruby::TypeInference
     end
 
     SolveMethodCallInCurrentScope = ->(application:, reference:, method_call_clue:) do
-      referenced_method = resolve_method(application:, scope: reference.scope, method_name: method_call_clue.method_name)
+      referenced_method = 
+        if reference.scope.class_method?
+          resolve_class_method(application:, scope: reference.scope.parent, method_name: method_call_clue.method_name)
+        elsif reference.scope.instance_method? && reference.scope.parent.present?
+          resolve_instance_method(application:, scope: reference.scope.parent, method_name: method_call_clue.method_name)
+        end
 
       return if referenced_method.nil?
 
@@ -53,8 +58,8 @@ module Holistic::Ruby::TypeInference
 
       return if referenced_scope.nil?
 
-      referenced_method = resolve_method(application:, scope: referenced_scope, method_name: method_call_clue.method_name)
-      referenced_method ||= application.extensions.dispatch(:resolve_method_call_known_scope, { reference:, referenced_scope:, method_call_clue: })
+      referenced_method = application.extensions.dispatch(:resolve_method_call_known_scope, { reference:, referenced_scope:, method_call_clue: })
+      referenced_method ||= resolve_class_method(application:, scope: referenced_scope, method_name: method_call_clue.method_name)
 
       Conclusion.done(referenced_method.fully_qualified_name) if referenced_method.present?
     end
@@ -101,10 +106,16 @@ module Holistic::Ruby::TypeInference
       nil
     end
 
-    def resolve_method(application:, scope:, method_name:)
+    def resolve_instance_method(application:, scope:, method_name:)
       method_fully_qualified_name = "#{scope.fully_qualified_name}##{method_name}"
 
       application.scopes.find_by_fully_qualified_name(method_fully_qualified_name)
     end
+
+    def resolve_class_method(application:, scope:, method_name:)
+      method_fully_qualified_name = "#{scope.fully_qualified_name}.#{method_name}"
+
+      application.scopes.find_by_fully_qualified_name(method_fully_qualified_name)
+    end
   end
 end

data/lib/holistic/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Holistic
-  VERSION = "0.1.1"
+  VERSION = "0.1.4"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: holistic-ruby
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.4
 platform: ruby
 authors:
 - Luiz Vasconcellos
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-08-19 00:00:00.000000000 Z
+date: 2023-08-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: syntax_tree